home *** CD-ROM | disk | FTP | other *** search
/ Software Vault: The Gold Collection / Software Vault - The Gold Collection (American Databankers) (1993).ISO / cdr25 / os2dbutl.zip / LUDOSPY.C < prev    next >
C/C++ Source or Header  |  1993-03-09  |  122KB  |  3,036 lines
  1. /*............................................................................
  2. .                                                                            .
  3. .                                                                            .
  4. .                                                                            .
  5. .               --- Series III Life and Health Presents ---                  .
  6. .                                                                            .
  7. .                                                                            .
  8. .                                                                            .
  9. .                                                                            .
  10. .   Program ID......: LUDOSNAP.C                                             .
  11. .                                                                            .
  12. .   Program Title...:                                                        .
  13. .                                                                            .
  14. .   Version Number..: 1.00                                                   .
  15. .                                                                            .
  16. .   Operating System: OS/2                                                   .
  17. .                                                                            .
  18. .   Description.....:                                                        .
  19. .                                                                            .
  20. .                                                                            .
  21. .                                                                            .
  22. .   Parameters:                                                              .
  23. .                                                                            .
  24. .          Type           Name                 Description                   .
  25. .       ------------   --------------    ----------------------------        .
  26. .           N/A                                                              .
  27. .                                                                            .
  28. .                                                                            .
  29. .   Return Values:                                                           .
  30. .                                                                            .
  31. .        Type         Value      #define                Description          .
  32. .       --------      -----    ----------------     -----------------------  .
  33. .           N/A                                                              .
  34. .                                                                            .
  35. .                                                                            .
  36. .   Application Function Calls (Internal):                                   .
  37. .                                                                            .
  38. .            Function Name                    Description                    .
  39. .       ------------------------     --------------------------------        .
  40. .                                                                            .
  41. .                                                                            .
  42. .   Application Function Calls (External):                                   .
  43. .                                                                            .
  44. .            Function Name                    Description                    .
  45. .       ------------------------     --------------------------------        .
  46. .                N/A                                                         .
  47. .                                                                            .
  48. .   Special Processing:                                                      .
  49. .                                                                            .
  50. .                                                                            .
  51. .                                                                            .
  52. .   Internal Tables:                                                         .
  53. .                                                                            .
  54. .            Table Name                       Description                    .
  55. .       --------------------------   --------------------------------        .
  56. .            N/A                                                             .
  57. .                                                                            .
  58. .                                                                            .
  59. .   Application Specific Hungarian Prefixes:                                 .
  60. .                                                                            .
  61. .       Prefix              Description                                      .
  62. .       ------       --------------------------------------------            .
  63. .        N/A                                                                 .
  64. .                                                                            .
  65. .                                                                            .
  66. .   Member of Object Library:  N/A                                           .
  67. .                                                                            .
  68. .   Member of Dynamic Link Library:  N/A                                     .
  69. .                                                                            .
  70. .                                                                            .
  71. .                                                                            .
  72. ..............................................................................
  73. .                                                                            .
  74. .                       M A I N T E N A N C E    L O G                       .
  75. .                                                                            .
  76. .                                                                            .
  77. .   SI Number      Date      PGMR          Description                       .
  78. .   ---------    --------    ----    ------------------------------          .
  79. .                                                                            .
  80. .                                                                            .
  81. ............................................................................*/
  82.  
  83. /*....................................................................
  84. :                                                                    :
  85. :   Defines                                                          :
  86. :                                                                    :
  87. :...................................................................*/
  88.  
  89. #define INCL_BASE
  90. #define EXTERN
  91. #define TRUE 1
  92. #define FALSE 0
  93. #define SLEEP_TIME 950L
  94. #define STACK_SIZE 1024
  95. #define ARGS NULL
  96. #define MAX_USERS 101
  97. #define DELAY 1000L
  98.  
  99. #define BLACK 0
  100. #define BLUE 1
  101. #define GREEN 2
  102. #define CYAN 3
  103. #define RED 4
  104. #define MAGENTA 5
  105. #define BROWN 6
  106. #define WHITE 7
  107. #define GREY 8
  108. #define LT_BLUE 9
  109. #define LT_GREEN 10
  110. #define LT_CYAN 11
  111. #define LT_RED 12
  112. #define LT_MAGENTA 13
  113. #define YELLOW 14
  114. #define BRI_WHITE 15
  115. #define LT_RED_BLINK 28
  116.  
  117. #define WM_REDRAW          WM_USER  +251
  118. #define WM_FINISH          WM_USER  +252
  119.  
  120. /*....................................................................
  121. :                                                                    :
  122. :   OS/2 include headers                                             :
  123. :                                                                    :
  124. :...................................................................*/
  125.  
  126. #include "LUDOSPY.H"
  127.  
  128. /*....................................................................
  129. :                                                                    :
  130. :   SQL include headers                                              :
  131. :                                                                    :
  132. :...................................................................*/
  133.  
  134. #include <sql.h>
  135. #include <sqlca.h>
  136. #include <sqlenv.h>
  137. #include <sqlutil.h>
  138.  
  139. /*....................................................................
  140. :                                                                    :
  141. :   Global variables                                                 :
  142. :                                                                    :
  143. :...................................................................*/
  144.  
  145. char           sz_log[15];
  146. char           sz_mode[9];
  147. char           sz_stats[256];
  148. char           sz_code[20];
  149. char           sz_title[80];
  150. char           sz_dbase[10];
  151. char           sz_buff[81];
  152. char           sz_conn[5];
  153. char           sz_conns[10];
  154. char           sz_nodename[9]; 
  155. char           sz_partner_lu[9];
  156. char           sz_local_lu[9]; 
  157. char           sz_comment[31];
  158. char           sz_db_entry[9];
  159. char           sz_time_out[30];
  160. char           sz_date_time[26];
  161. char           sz_user_buff[256];
  162. char           sz_alias[25][9];
  163. char           sz_node[25][9];
  164. char           sz_un_alias[25][9];
  165. char           sz_un_nodename[25][9];
  166. char           sz_trans_con[9]; 
  167. char           sz_req_con[9];
  168. char           sz_req_cur[9];
  169. char           sz_rds_name[9];
  170. char           sz_new_title[22];
  171. char           sz_scan[10];
  172.  
  173. BYTE           stack[STACK_SIZE];
  174. BYTE           wch_stack[STACK_SIZE];
  175.  
  176. unsigned short us_db_count;
  177. unsigned short us_count_dir;
  178. unsigned short us_count_node;
  179. unsigned short us_row;
  180. unsigned short us_col;
  181. unsigned short us_hand_dir;
  182. unsigned short us_hand_node;
  183. unsigned short us_scan;
  184.  
  185. HWND hWndDbDlg;
  186. HWND hWndReFresh;
  187.  
  188. /*....................................................................
  189. :                                                                    :
  190. :   Structures                                                       :
  191. :                                                                    :
  192. :...................................................................*/
  193.  
  194. struct sqlca sqlca;
  195.  
  196. /* System Status data structure */
  197.  
  198. struct dbstat
  199. {
  200.   unsigned long  current_time;
  201.            long  time_zone_disp1;
  202.   unsigned char  product_name[SQL_PRODNAME_SZ];
  203.   unsigned char  component_id[SQL_COMPID_SZ];
  204.   unsigned char  reserved1;                      /* Reserved byte  */
  205.   unsigned char  release_lvl[SQL_RLSLVL_SZ];
  206.   unsigned char  corr_serv_lvl[SQL_CORRLVL_SZ];
  207.   unsigned long  backup_time;             /* Last backup time           */
  208.            long  time_zone_disp2;         /* Time zone of backup time   */
  209.   unsigned short connects;                /* Number of current users    */
  210.   unsigned char  db_alias[SQL_DBSTAT_ALIAS_SZ];  /* Alias name          */
  211.   unsigned char  db_name[SQL_DBSTAT_DBNAME_SZ];  /* Database name       */
  212.   unsigned char  location;                /* Local / Remote Database    */
  213.   unsigned char  reserved2;               /* Reserved byte              */
  214.   unsigned char  drive[SQL_DRIVE_SZ];     /* Drive containing database  */
  215.   unsigned char  node[SQL_NNAME_SZ];      /* Node containing database   */
  216.   unsigned char  db_type[SQL_DBTYP_SZ];   /* "OS2 DBM"                  */
  217.   struct userstat
  218.      {
  219.      unsigned long  con_trans;            /* Transactions since connect */
  220.      unsigned long  con_reqs;             /* Requests since connect     */
  221.      unsigned long  cur_reqs;             /* Requests current transact  */
  222.      unsigned long  connect_time;         /* Time since connect         */
  223.      unsigned long  trans_time;           /* Time since current transact*/
  224.      unsigned char  authid[SQL_USERID_SZ];/* User's Id                  */
  225.      unsigned char  node[SQL_NNAME_SZ];   /* Nodename of connected user */
  226.      unsigned short authority_lvl;        /* User's authority level     */
  227.      unsigned char  trans_state;          /* Transaction state          */
  228.      unsigned char  lock_state;           /* Transaction lock state     */
  229.      } ustat[MAX_USERS];
  230.   } *pdbstat;
  231.  
  232. struct dbstat basestat;
  233.  
  234. time_t         bintime;
  235. time_t         con_time;
  236.  
  237. struct tm *curtime;
  238. struct tm *out_time;
  239.  
  240. struct sqlca sqlca;
  241. struct sqledinfo *st_info;
  242. struct sqleninfo *st_node;
  243. struct sql_authorizations st_auth, *p_auth = &st_auth;
  244.  
  245. /*....................................................................
  246. :                                                                    :
  247. :   Bit structures                                                   :
  248. :                                                                    :
  249. :...................................................................*/
  250.  
  251.   struct logical
  252.      {
  253.      unsigned cat    : 1;  /*TRUE catolog database                  */
  254.      unsigned node   : 1;  /*TRUE catolog node                      */
  255.      unsigned noconn : 1;  /*TRUE there is no connections           */
  256.      unsigned append : 1;  /*TRUE append log file                   */
  257.      unsigned over   : 1;  /*TRUE overwrite log file                */
  258.      unsigned none   : 1;  /*TRUE do not use log file               */
  259.      unsigned tend   : 1;  /*TRUE to end the refresh thread         */
  260.      unsigned draw   : 1;  /*TRUE if screen is already drawing      */
  261.      unsigned time   : 1;  /*TRUE if refresh time has expired       */
  262.      }
  263.      bit_flag;
  264.  
  265. /*....................................................................
  266. :                                                                    :
  267. :   File Structures                                                  :
  268. :                                                                    :
  269. :...................................................................*/
  270.  
  271. FILE *spyfile;
  272.  
  273. /*....................................................................
  274. :                                                                    :
  275. :   function prototypes                                              :
  276. :                                                                    :
  277. :...................................................................*/
  278.  
  279. void dir_scan(void);
  280. void db_crash(void);
  281. void get_time(void);
  282. void node_scan(void);
  283. void sort_users(void);
  284. void write_db_stats(void);
  285. void write_user_stats(void);
  286. void refresh_thread(void);
  287. void wch_thread(void);
  288.  
  289. /***************************************************************************/
  290. /*                                                                         */
  291. /* Presentation Manager Program Main Body                                  */
  292. /*                                                                         */
  293. /* The following routine is the Presentation Manager program Main Body.    */
  294. /* The Main Body of a PM program is concerned with associating the         */
  295. /* application with the Presentation Manager system, creating its          */
  296. /* message queue, registering and displaying its main window, servicing    */
  297. /* its message queue during the time that the application is active,       */
  298. /* and disassociating the application from PM when the user is finished    */
  299. /* with the application. The remaining parts of this source module that    */
  300. /* are concerned with the Presentation Manager are the application's       */
  301. /* window procedures (main window procedure, child window procedures,      */
  302. /* and dialog window procedures) that process the messages associated      */
  303. /* with the application's various windows.                                 */
  304. /*                                                                         */
  305. /***************************************************************************/
  306.  
  307. SHORT cdecl main(argc, argv)
  308. int argc;
  309. char *argv[];
  310. {
  311.  QMSG qmsg;  /* MSG structure to store your messages                       */
  312.  PID  pid;   /* Process identifier for adding name to switch list          */
  313.  TID  tid;   /* Thread identifier                                          */
  314.  static CHAR szTitle[8];
  315.  
  316.  /* The WinInitialize routine initializes the Presentation Manager         */
  317.  /* facilities for use by this application and returns a handle to the     */
  318.  /* anchor block assigned to the application by PM.                        */
  319.  
  320.  bit_flag.append = FALSE;
  321.  bit_flag.over = FALSE;
  322.  bit_flag.none = TRUE;
  323.  bit_flag.draw = FALSE;
  324.  us_scan = 30;
  325.  
  326.  SQLGSTAR();
  327.  
  328.  if((hAB = WinInitialize(0)) == 0)
  329.     return(FALSE);
  330.   
  331.  /* The WinCreateMsgQueue call creates a message queue for this application*/
  332.  
  333.  if((hMQ = WinCreateMsgQueue(hAB, 0)) == 0)
  334.     return(FALSE);
  335.  
  336.  /* The following function registers the classes of all application windows*/
  337.  if(!cwRegisterClass())
  338.     return(FALSE);
  339.  
  340.  /**************************************************************************/
  341.  /* IPF Initialization Structure                                           */
  342.  /**************************************************************************/
  343.  
  344.  hiLUDOSPYHelp.cb = sizeof(HELPINIT);  /* size of init structure      */
  345.  hiLUDOSPYHelp.ulReturnCode = 0;
  346.  hiLUDOSPYHelp.pszTutorialName = 0; /* no tutorial                         */
  347.  hiLUDOSPYHelp.phtHelpTable = (PVOID)(0xffff0000 | ID_LUDOSPY);
  348.  hiLUDOSPYHelp.hmodAccelActionBarModule = 0;
  349.  hiLUDOSPYHelp.idAccelTable = 0;
  350.  hiLUDOSPYHelp.idActionBar = 0;
  351.  hiLUDOSPYHelp.pszHelpWindowTitle = "LUDOSPY";
  352.  hiLUDOSPYHelp.hmodHelpTableModule = 0;
  353.  hiLUDOSPYHelp.usShowPanelId = 0;
  354.  hiLUDOSPYHelp.pszHelpLibraryName = "LUDOSPY.HLP";
  355.  
  356.  /**************************************************************************/
  357.  /* Create Instance of IPF                                                 */
  358.  /**************************************************************************/
  359.  
  360.  hWndLUDOSPYHelp = WinCreateHelpInstance(hAB, &hiLUDOSPYHelp);
  361.  if(!hWndLUDOSPYHelp || hiLUDOSPYHelp.ulReturnCode)
  362.    {
  363.     WinMessageBox(HWND_DESKTOP, HWND_DESKTOP,
  364.                   (PSZ)"No help is available.",
  365.                   (PSZ) szAppName,
  366.                   1,
  367.                   MB_OK | MB_APPLMODAL | MB_MOVEABLE);
  368.     WinDestroyHelpInstance(hWndLUDOSPYHelp);
  369.    }
  370.  
  371.  /* The CreateWindow function creates a frame window for this application's*/
  372.  /* top window, and set the window's size and location as appropriate.     */
  373.  
  374.  WinLoadString(hAB, 0, IDS_TITLE, 8, szTitle);
  375.  hWndFrame = cwCreateWindow((HWND)HWND_DESKTOP,
  376.           FCF_TITLEBAR     |
  377.           FCF_SYSMENU      |
  378.           FCF_MINBUTTON    |
  379.           FCF_MAXBUTTON    |
  380.           FCF_SIZEBORDER   |
  381.           FCF_MENU         |
  382.           FCF_ACCELTABLE   |
  383.           FCF_SHELLPOSITION,
  384.           szAppName,
  385.           szTitle,
  386.           ID_LUDOSPY,
  387.           0, 0,
  388.           0, 0,
  389.           &hWndClient,
  390.           0L,SWP_MAXIMIZE | SWP_SHOW);
  391.  
  392.  if(hWndFrame == 0)
  393.     return(FALSE);
  394.  
  395.  /**************************************************************************/
  396.  /* Associate Instance of IPF                                              */
  397.  /**************************************************************************/
  398.  if(hWndLUDOSPYHelp)
  399.    WinAssociateHelpInstance(hWndLUDOSPYHelp, hWndFrame);
  400.  /* The following inline routine fills out the application's switch control*/
  401.  /* structure with the appropriate information to add the application's    */
  402.  /* name to the OS/2 Task Manager List, a list of the jobs currently       */
  403.  /* running on the computer.                                               */
  404.  
  405.  WinQueryWindowProcess(hWndFrame, &pid, &tid);
  406.  Swctl.hwnd = hWndFrame;                         /* Frame window handle    */
  407.  Swctl.idProcess = pid;                          /* Process identifier     */
  408.  Swctl.uchVisibility = SWL_VISIBLE;              /* visibility             */
  409.  Swctl.fbJump = SWL_JUMPABLE;                    /* Jump indicator         */
  410.  strcpy(Swctl.szSwtitle, szTitle);               /* Frame window title     */
  411.  hSwitch = WinAddSwitchEntry(&Swctl);
  412.    
  413.  /* The following is the message loop for the application.                 */
  414.  
  415.  while(WinGetMsg(hAB, (PQMSG)&qmsg, 0, 0, 0))
  416.        WinDispatchMsg(hAB,(PQMSG)&qmsg);
  417.  
  418.  /* Perform clean up before exiting application.                           */
  419.  /**************************************************************************/
  420.  /* Destroy Instance of IPF                                                */
  421.  /**************************************************************************/
  422.  if(hWndLUDOSPYHelp)
  423.     WinDestroyHelpInstance(hWndLUDOSPYHelp);
  424.  /* The following routine destroys the application's frame window (which   */
  425.  /* also destroys its child windows), destroys its message queue, and      */
  426.  /* disassociates the application from the Presentation Manager system.    */
  427.  
  428.  WinDestroyWindow(hWndFrame); /* Destroy the frame window                  */
  429.  WinDestroyMsgQueue(hMQ);     /* Destroy this application's message queue  */
  430.  WinTerminate(hAB);           /* Terminate this application's use of the   */
  431.                               /* Presentation Manager resources            */
  432. } /* end of main */
  433.  
  434.  
  435. /* The following Dialog box calls are generated for the dialog boxes that  */
  436. /* have been selected as "Unlinked" dialog boxes.  To use these calls,     */
  437. /* simply copy them to the appropriate location in the application.        */
  438.  
  439. #if 0
  440.  
  441.    WinDlgBox(HWND_DESKTOP, hWnd, (PFNWP)CATMsgProc, 
  442.              0, IDLG_CAT, (PBYTE)hWnd);
  443.  
  444.    WinDlgBox(HWND_DESKTOP, hWnd, (PFNWP)NODEMsgProc, 
  445.              0, IDLG_NODE, (PBYTE)hWnd);
  446.  
  447.    WinDlgBox(HWND_DESKTOP, hWnd, (PFNWP)NO_CONMsgProc, 
  448.              0, IDLG_NO_CON, (PBYTE)hWnd);
  449.  
  450.    WinDlgBox(HWND_DESKTOP, hWnd, (PFNWP)STATUSMsgProc, 
  451.              0, IDLG_STATUS, (PBYTE)hWnd);
  452.  
  453. #endif
  454.  
  455. /***************************************************************************/
  456. /*                                                                         */   
  457. /* Main Window Procedure                                                   */
  458. /*                                                                         */
  459. /* This procedure provides service routines for the general PM events      */
  460. /* (messages) that PM sends to the window, as well as the user             */
  461. /* initiated events (messages) that are generated when the user selects    */
  462. /* the action bar and pulldown menu controls or the corresponding          */
  463. /* keyboard accelerators.                                                  */
  464. /*                                                                         */
  465. /* The SWITCH statement shown below distributes the window messages to     */
  466. /* the respective message service routines, which are set apart by the     */
  467. /* CASE statements. The window procedures must provide an appropriate      */
  468. /* service routine for its end user initiated messages, as well as the     */
  469. /* general PM messages (like the WM_CLOSE message). If a message is        */
  470. /* sent to this procedure for which there is no programmed CASE clause     */
  471. /* (i.e., no service routine), the message is defaulted to the             */
  472. /* WinDefWindowProc function, where it is disposed of by PM.               */
  473. /*                                                                         */
  474. /***************************************************************************/
  475.  
  476. MRESULT EXPENTRY WndProc(hWnd, message, mp1, mp2)
  477. HWND hWnd;
  478. USHORT message;
  479. MPARAM mp1;
  480. MPARAM mp2;
  481. {                        /* Beginning of message processor                 */
  482.    HPS hPS;              /* Handle for the Presentation Space              */
  483.    RECTL rClient;        /* Handle to rectangle formed by client area      */
  484.    USHORT rc;            /* common return code value                       */
  485.  
  486.    switch(message)
  487.      {
  488.       case WM_COMMAND:
  489.         /* The PM messages for action bar and pulldown menu items are      */
  490.         /* processed in this routine.                                      */
  491.   
  492.            switch(SHORT1FROMMP(mp1))
  493.             {
  494.              case IDM_F_EXIT:
  495.                   /* Place User Code to respond to the                     */
  496.                   /* Menu Item Named "E~xit" here.                         */
  497.                   WinPostQueueMsg(hMQ, WM_QUIT, NULL, NULL); 
  498.                   break;
  499.  
  500.              case IDM_P_SCANINTERVAL:
  501.                   /* This makes a call to the dialog box named             */
  502.                   /* "INTERVAL" rc will receive the return code            */
  503.                   /* sent when the dialog box is closed                    */
  504.                   rc = WinDlgBox(HWND_DESKTOP, hWnd, (PFNWP)INTERVALMsgProc,
  505.                                  0, IDLG_INTERVAL, (PBYTE)hWnd);
  506.                   break;
  507.  
  508.              case IDM_P_FILEOPTIONS:
  509.                   /* This makes a call to the dialog box named             */
  510.                   /* "FILES" rc will receive the return code               */
  511.                   /* sent when the dialog box is closed                    */
  512.                   rc = WinDlgBox(HWND_DESKTOP, hWnd, (PFNWP)FILESMsgProc,
  513.                                  0, IDLG_FILES, (PBYTE)hWnd);
  514.                   break;
  515.  
  516.              case IDM_P_DATABASE:
  517.                   if (!WinIsWindow(hAB, hWndDATABASE))
  518.                     {
  519.                       hWnd = WinLoadDlg(HWND_DESKTOP, hWnd,
  520.                          (PFNWP)DATABASEMsgProc, 0, IDLG_DATABASE, (PBYTE)hWnd);
  521.                     }
  522.                    else
  523.                     WinSetFocus(HWND_DESKTOP, hWndDATABASE);
  524.                   break;
  525.  
  526.              case IDM_P_CATOLOGDATABASE:
  527.                   /* This makes a call to the dialog box named             */
  528.                   /* "CAT" rc will receive the return code                 */
  529.                   /* sent when the dialog box is closed                    */
  530.                   rc = WinDlgBox(HWND_DESKTOP, hWnd, (PFNWP)CATMsgProc,
  531.                                  0, IDLG_CAT, (PBYTE)hWnd);
  532.                   break;
  533.  
  534.              case IDM_P_UNCATOLOGDATABASE:
  535.                   /* This makes a call to the dialog box named             */
  536.                   /* "UN_CAT" rc will receive the return code              */
  537.                   /* sent when the dialog box is closed                    */
  538.                   rc = WinDlgBox(HWND_DESKTOP, hWnd, (PFNWP)UN_CATMsgProc,
  539.                                  0, IDLG_UN_CAT, (PBYTE)hWnd);
  540.                   break;
  541.  
  542.              case IDM_P_CATOLOGNODE:
  543.                   /* This makes a call to the dialog box named             */
  544.                   /* "NODE" rc will receive the return code                */
  545.                   /* sent when the dialog box is closed                    */
  546.                   rc = WinDlgBox(HWND_DESKTOP, hWnd, (PFNWP)NODEMsgProc,
  547.                                  0, IDLG_NODE, (PBYTE)hWnd);
  548.                   break;
  549.  
  550.              case IDM_P_UNCATOLOGNODE:
  551.                   /* This makes a call to the dialog box named             */
  552.                   /* "UN_NODE" rc will receive the return code             */
  553.                   /* sent when the dialog box is closed                    */
  554.                   rc = WinDlgBox(HWND_DESKTOP, hWnd, (PFNWP)UN_NODEMsgProc,
  555.                                  0, IDLG_UN_NODE, (PBYTE)hWnd);
  556.                   break;
  557.  
  558.  
  559.             case IDM_H_HELPFORHELP:
  560.                  if(hWndLUDOSPYHelp)
  561.                     WinSendMsg(hWndLUDOSPYHelp, HM_DISPLAY_HELP, 0L, 0L);
  562.                  break;
  563.  
  564.  
  565.              default:
  566.                   break; /* End of default case for switch(mp1) */
  567.             }
  568.            break; /* End of WM_COMMAND */
  569.  
  570.  
  571.       case HM_QUERY_KEYS_HELP:
  572.            /* If the user requests Keys Help from the help pulldown,       */
  573.            /* IPF sends the HM_QUERY_KEYS_HELP message to the application, */
  574.            /* which should return the panel id of the Keys Help panel      */
  575.            return((MRESULT)999);
  576.            break;
  577.  
  578.       case HM_ERROR:
  579.            /* If an IPF error occurs, an HM_ERROR message will be sent to  */
  580.            /* the application.                                             */
  581.            if(hWndLUDOSPYHelp && ((ULONG)mp1) == HMERR_NO_MEMORY)
  582.              {
  583.               WinMessageBox(HWND_DESKTOP, HWND_DESKTOP,
  584.                             (PSZ) "Help Terminated Due to Error",
  585.                             (PSZ) "Help Error",
  586.                             1,
  587.                             MB_OK | MB_APPLMODAL | MB_MOVEABLE);
  588.               WinDestroyHelpInstance(hWndLUDOSPYHelp);
  589.              }
  590.             else
  591.              {
  592.               WinMessageBox(HWND_DESKTOP, HWND_DESKTOP,
  593.                             (PSZ) "Help Error Occurred",
  594.                             (PSZ) "Help Error",
  595.                             1,
  596.                             MB_OK | MB_APPLMODAL | MB_MOVEABLE);
  597.              }
  598.            break;
  599.  
  600.       case WM_CREATE:
  601.            /* The WM_CREATE message is sent to a window when an application*/
  602.            /* requests that the window be created.  The window procedure   */
  603.            /* for the new window receives this message after the window is */
  604.            /* created, but before the window becomes visible.              */
  605.            /*                                                              */
  606.            cwSetInitDlgStatus(hWnd);
  607.            break; /* End of WM_CREATE */
  608.  
  609.       case WM_MOUSEMOVE:
  610.            return(WinDefWindowProc(hWnd, message, mp1, mp2));
  611.            break;
  612.  
  613.       case WM_SIZE:     /* code for sizing client area                     */
  614.            break;       /* End of WM_SIZE                                  */
  615.     
  616.       case WM_PAINT:    /* code for the window's client area               */
  617.            /* Obtain a handle to a cache presentation space                */
  618.            hPS = WinBeginPaint(hWnd, 0, 0);
  619.  
  620.            /* Determine the size of the client area                        */
  621.            WinQueryWindowRect(hWnd, &rClient);
  622.  
  623.            /* Fill the background with the default background color        */
  624.            WinFillRect(hPS, &rClient, CLR_CYAN);
  625.  
  626.            /* return presentation space to state before WinBeginPaint      */
  627.            WinEndPaint(hPS);
  628.            break; /* End of WM_PAINT */
  629.  
  630.  
  631.       case WM_CLOSE:  /* close the window                                  */
  632.            if(hWnd != hWndClient)
  633.              break;
  634.            cwFreeDlgMemory(hWnd);
  635.            return(WinDefWindowProc(hWnd, message, mp1, mp2));
  636.            break; /* End of WM_CLOSE */
  637.      
  638.       default:
  639.            /* For any message for which you don't specifically provide a   */
  640.            /* service routine, you should return the message to PM using   */
  641.            /* the WinDefWindowProc function.                               */
  642.            return(WinDefWindowProc(hWnd, message, mp1, mp2));
  643.            break;  /* End of default */
  644.      } 
  645.    return(0L);
  646. } /* End of WndProc */
  647.  
  648. /***************************************************************************/
  649. /*                                                                         */
  650. /* Dialog Window Procedure                                                 */
  651. /*                                                                         */
  652. /* This procedure is associated with the dialog box that is included in    */
  653. /* the function name of the procedure. It provides the service routines    */
  654. /* for the events (messages) that occur because the end user operates      */
  655. /* one of the dialog box's buttons, entry fields, or controls.             */
  656. /*                                                                         */
  657. /* The SWITCH statement in the function distributes the dialog box         */
  658. /* messages to the respective service routines, which are set apart by     */
  659. /* the CASE clauses. Like any other PM window, the Dialog Window           */
  660. /* procedures must provide an appropriate service routine for their end    */
  661. /* user initiated messages as well as for the general PM messages (like    */
  662. /* the WM_CLOSE message). If a message is sent to this procedure for       */
  663. /* which there is no programmed CASE condition (no service routine),       */
  664. /* the message is defaulted to the WinDefDlgProc function, where it is     */
  665. /* disposed of by PM.                                                      */
  666. /*                                                                         */
  667. /***************************************************************************/
  668.  
  669. MRESULT EXPENTRY INTERVALMsgProc(hWndDlg, message, mp1, mp2)
  670. HWND hWndDlg;
  671. USHORT message;
  672. MPARAM mp1;
  673. MPARAM mp2;
  674. { 
  675.  static SHORT sfValidate = TRUE;
  676.  INT    i;
  677.  static HWND  hWndParent;
  678.           
  679.  switch(message)
  680.    {
  681.     case WM_INITDLG:
  682.          hWndParent = (HWND)mp2;
  683.          cwCenter(hWndDlg, (HWND)hWndParent);
  684.          WinSendDlgItemMsg(hWndDlg, 257, EM_SETTEXTLIMIT, (MPARAM)4, NULL);
  685.          break; /* End of WM_INITDLG */
  686.    
  687.     case WM_CONTROL:
  688.          switch(SHORT1FROMMP(mp1))
  689.            {
  690.             case 257: /* Entry field                                       */
  691.                  switch(SHORT2FROMMP(mp1)) /* switch on Notification Code  */
  692.                    { 
  693.                     case EN_SETFOCUS:/* Entry field is receiving the focus */
  694.                          break;
  695.  
  696.                     case EN_KILLFOCUS: /* Entry field is losing the focus  */
  697.                          break;
  698.  
  699.                     default: /* Default other messages                     */
  700.                          return(WinDefDlgProc(hWndDlg, message, mp1, mp2));
  701.                          break;
  702.                    }
  703.                  break;
  704.  
  705.            }
  706.          break; /* End of WM_CONTROL */
  707.    
  708.     case WM_COMMAND:
  709.          switch(SHORT1FROMMP(mp1))
  710.            {
  711.             case DID_OK: /* Button text: "Ok"                              */
  712.                  WinQueryDlgItemText(hWndDlg, 257,
  713.                                      sizeof(sz_scan),
  714.                                      sz_scan);
  715.  
  716.                  us_scan = atoi(sz_scan);
  717.  
  718.                  WinDismissDlg(hWndDlg, TRUE);
  719.                  break;
  720.  
  721.             case DID_CANCEL: /* Button text: "Cancel"                      */
  722.                  /* Ignore data values entered into the dialog controls    */
  723.                  /* and dismiss the dialog window                          */
  724.                  WinDismissDlg(hWndDlg, FALSE);
  725.                  break;
  726.  
  727.             case 260: /* Button text: "Help"                               */
  728.                  break;
  729.  
  730.            }
  731.          break; /* End of WM_COMMAND */
  732.                                
  733.     case WM_CLOSE:
  734.          WinPostMsg(hWndDlg, WM_COMMAND, MPFROMSHORT(DID_CANCEL), 0L);
  735.          break; /* End of WM_CLOSE */
  736.            
  737.     case WM_FAILEDVALIDATE:
  738.          WinAlarm(HWND_DESKTOP, WA_ERROR);
  739.          sfValidate = FALSE;
  740.          WinSetFocus(HWND_DESKTOP, WinWindowFromID(hWndDlg, SHORT1FROMMP(mp1)));
  741.          sfValidate = TRUE;
  742.          return((MRESULT)TRUE);
  743.          break; /* End of WM_FAILEDVALIDATE */
  744.  
  745.     default:
  746.          return(WinDefDlgProc(hWndDlg, message, mp1, mp2));
  747.          break;
  748.    }
  749.  return FALSE;
  750. } /* End of INTERVALMsgProc */
  751.  
  752.  
  753. /***************************************************************************/
  754. /*                                                                         */
  755. /* Dialog Window Procedure                                                 */
  756. /*                                                                         */
  757. /* This procedure is associated with the dialog box that is included in    */
  758. /* the function name of the procedure. It provides the service routines    */
  759. /* for the events (messages) that occur because the end user operates      */
  760. /* one of the dialog box's buttons, entry fields, or controls.             */
  761. /*                                                                         */
  762. /* The SWITCH statement in the function distributes the dialog box         */
  763. /* messages to the respective service routines, which are set apart by     */
  764. /* the CASE clauses. Like any other PM window, the Dialog Window           */
  765. /* procedures must provide an appropriate service routine for their end    */
  766. /* user initiated messages as well as for the general PM messages (like    */
  767. /* the WM_CLOSE message). If a message is sent to this procedure for       */
  768. /* which there is no programmed CASE condition (no service routine),       */
  769. /* the message is defaulted to the WinDefDlgProc function, where it is     */
  770. /* disposed of by PM.                                                      */
  771. /*                                                                         */
  772. /***************************************************************************/
  773.  
  774. MRESULT EXPENTRY FILESMsgProc(hWndDlg, message, mp1, mp2)
  775. HWND hWndDlg;
  776. USHORT message;
  777. MPARAM mp1;
  778. MPARAM mp2;
  779. { 
  780.  static SHORT sfValidate = TRUE;
  781.  INT    i;
  782.  static HWND  hWndParent;
  783.           
  784.  switch(message)
  785.    {
  786.     case WM_INITDLG:
  787.          hWndParent = (HWND)mp2;
  788.          cwCenter(hWndDlg, (HWND)hWndParent);
  789.  
  790.          bit_flag.append = FALSE;
  791.          bit_flag.over = FALSE;
  792.          bit_flag.none = TRUE;
  793.  
  794.          break; /* End of WM_INITDLG */
  795.    
  796.     case WM_CONTROL:
  797.          switch(SHORT1FROMMP(mp1))
  798.            {
  799.             case 256: /* Radiobutton text: "~Append"                       */
  800.                  bit_flag.append = TRUE;
  801.                  bit_flag.over = FALSE;
  802.                  bit_flag.none = FALSE;
  803.                  break;
  804.  
  805.             case 257: /* Radiobutton text: "Over~write"                    */
  806.                  bit_flag.over = TRUE;
  807.                  bit_flag.none = FALSE;
  808.                  bit_flag.append = FALSE;
  809.                  break;
  810.  
  811.             case 258: /* Radiobutton text: "~None"                         */
  812.                  bit_flag.none = TRUE;
  813.                  bit_flag.append = FALSE;
  814.                  bit_flag.over = FALSE;
  815.                  break;
  816.  
  817.            }
  818.          break; /* End of WM_CONTROL */
  819.    
  820.     case WM_COMMAND:
  821.          switch(SHORT1FROMMP(mp1))
  822.            {
  823.             case DID_OK: /* Button text: "Ok"                              */
  824.                  if (bit_flag.append)
  825.                     {
  826.                     if((spyfile = fopen(sz_log, "a")) == NULL)
  827.                        {
  828.                        perror("Can't open log file...");
  829.                        }
  830.                     }
  831.  
  832.                  if (bit_flag.over)
  833.                     {
  834.                     if((spyfile = fopen(sz_log, "w")) == NULL)
  835.                        {
  836.                        perror("Can't open log file...");
  837.                        }
  838.                     }
  839.  
  840.                  WinDismissDlg(hWndDlg, TRUE);
  841.                  break;
  842.  
  843.             case DID_CANCEL: /* Button text: "Cancel"                      */
  844.                  /* Ignore data values entered into the dialog controls    */
  845.                  /* and dismiss the dialog window                          */
  846.                  WinDismissDlg(hWndDlg, FALSE);
  847.                  break;
  848.  
  849.             case 261: /* Button text: "Help"                               */
  850.                  break;
  851.  
  852.            }
  853.          break; /* End of WM_COMMAND */
  854.                                
  855.     case WM_CLOSE:
  856.          WinPostMsg(hWndDlg, WM_COMMAND, MPFROMSHORT(DID_CANCEL), 0L);
  857.          break; /* End of WM_CLOSE */
  858.            
  859.     case WM_FAILEDVALIDATE:
  860.          WinAlarm(HWND_DESKTOP, WA_ERROR);
  861.          sfValidate = FALSE;
  862.          WinSetFocus(HWND_DESKTOP, WinWindowFromID(hWndDlg, SHORT1FROMMP(mp1)));
  863.          sfValidate = TRUE;
  864.          return((MRESULT)TRUE);
  865.          break; /* End of WM_FAILEDVALIDATE */
  866.  
  867.     default:
  868.          return(WinDefDlgProc(hWndDlg, message, mp1, mp2));
  869.          break;
  870.    }
  871.  return FALSE;
  872. } /* End of FILESMsgProc */
  873.  
  874.  
  875. /***************************************************************************/
  876. /*                                                                         */
  877. /* Dialog Window Procedure                                                 */
  878. /*                                                                         */
  879. /* This procedure is associated with the dialog box that is included in    */
  880. /* the function name of the procedure. It provides the service routines    */
  881. /* for the events (messages) that occur because the end user operates      */
  882. /* one of the dialog box's buttons, entry fields, or controls.             */
  883. /*                                                                         */
  884. /* The SWITCH statement in the function distributes the dialog box         */
  885. /* messages to the respective service routines, which are set apart by     */
  886. /* the CASE clauses. Like any other PM window, the Dialog Window           */
  887. /* procedures must provide an appropriate service routine for their end    */
  888. /* user initiated messages as well as for the general PM messages (like    */
  889. /* the WM_CLOSE message). If a message is sent to this procedure for       */
  890. /* which there is no programmed CASE condition (no service routine),       */
  891. /* the message is defaulted to the WinDefDlgProc function, where it is     */
  892. /* disposed of by PM.                                                      */
  893. /*                                                                         */
  894. /***************************************************************************/
  895.  
  896. MRESULT EXPENTRY DATABASEMsgProc(hWndDlg, message, mp1, mp2)
  897. HWND hWndDlg;
  898. USHORT message;
  899. MPARAM mp1;
  900. MPARAM mp2;
  901. { 
  902.  static SHORT sfValidate = TRUE;
  903.  INT    i, us_item_index;
  904.  static HWND  hWndParent;
  905.  static USHORT rc;
  906.  char   *pspace;
  907.           
  908.  switch(message)
  909.    {
  910.     case WM_INITDLG:
  911.          hWndParent = (HWND)mp2;
  912.          cwCenter(hWndDlg, (HWND)hWndParent);
  913.          hWndDbDlg = hWndDlg;
  914.  
  915.          SQLGDOPS('0', &us_hand_dir, &us_count_dir, &sqlca);
  916.  
  917.          strcpy(sz_alias[0], "--New--");
  918.  
  919.          for(i=1;i<us_count_dir+1;i++)
  920.             {
  921.             SQLGDGNE(us_hand_dir, &st_info, &sqlca);
  922.             strncpy(sz_alias[i], st_info->alias, 8);
  923.             sz_alias[i][8] = '\0';
  924.             }
  925.  
  926.          SQLGDCLS(us_hand_dir, &sqlca);
  927.  
  928.          for(i=0;i<us_count_dir+1;i++)
  929.             {
  930.             WinSendDlgItemMsg(hWndDlg,
  931.                                   256,
  932.                         LM_INSERTITEM,
  933.               MPFROM2SHORT(LIT_END,0),
  934.                 MPFROMP(sz_alias[i]));
  935.             } 
  936.          break;
  937.    
  938.     case WM_CONTROL:
  939.          switch(SHORT1FROMMP(mp1))
  940.            {
  941.             case 256: /* List box                                          */
  942.                  us_item_index = (USHORT)WinSendDlgItemMsg(hWndDlg,
  943.                                                                256,
  944.                                                  LM_QUERYSELECTION,
  945.                                                        (short)NULL,
  946.                                                       (short)NULL);
  947.                        
  948.                   if (us_item_index == LIT_NONE)
  949.                     {
  950.                     strcpy(sz_dbase,"--New--");
  951.                     }
  952.                  else
  953.                     {
  954.                     strcpy(sz_dbase, sz_alias[us_item_index]);
  955.  
  956.                     if ((pspace = strchr(sz_dbase, ' ')) != NULL)
  957.                        {
  958.                        *pspace = '\0';
  959.                        }
  960.  
  961.                     sz_dbase[8] = '\0';
  962.                     strcpy(sz_log, sz_dbase);
  963.                     sz_log[8] = '\0';
  964.                     strcat(sz_log, ".LOG");
  965.  
  966.                     strcpy(sz_new_title, "Ludospy on ");
  967.                     strcat(sz_new_title, sz_dbase);
  968.  
  969.                     WinSetWindowText(hWndFrame, sz_new_title);
  970.  
  971. /*
  972.                     SQLGSTRD(0, strlen(sz_dbase), 'S', &sqlca, 0, sz_dbase);
  973.  
  974.                     if (sqlca.sqlcode != 0)
  975.                        {
  976.                        DosBeep(500,500);
  977.                        }
  978.  
  979.                     st_auth.sql_authorizations_len = sizeof(st_auth);
  980.  
  981.                     SQLGADAU(p_auth, &sqlca);
  982.  
  983.                     if (sqlca.sqlcode != 0)
  984.                        {
  985.                        DosBeep(500,500);
  986.                        }
  987. */
  988.                     }
  989.  
  990.                  break;
  991.  
  992.            }
  993.          break;
  994.    
  995.     case WM_COMMAND:
  996.          switch(SHORT1FROMMP(mp1))
  997.            {
  998.             case DID_OK: /* Button text: "Ok"                              */
  999.                  WinDestroyWindow(hWndDlg);
  1000.                  hWndDATABASE = 0;
  1001.               
  1002.                  if ((strcmp(sz_dbase, "--New--")) == 0)
  1003.                     {
  1004.                     rc = WinDlgBox(HWND_DESKTOP, hWndDlg,
  1005.                            (PFNWP)CATMsgProc,
  1006.                            0, IDLG_CAT, (PBYTE)hWndParent);
  1007.  
  1008.                     if (rc)
  1009.                        {
  1010.                         WinSendDlgItemMsg(hWndDlg,
  1011.                                               256,
  1012.                                     LM_INSERTITEM,
  1013.                           MPFROM2SHORT(LIT_END,0),
  1014.                            MPFROMP(sz_alias[us_count_dir]));
  1015.                        }
  1016.                     }
  1017.                  else
  1018.                     {
  1019.                     bit_flag.noconn = FALSE;
  1020.                     rc = WinLoadDlg(HWND_DESKTOP, HWND_DESKTOP, /* hWndDlg */
  1021.                            NULL, NULL,             /* 0, (PFNWP)STATUSMsgProc, */
  1022.                            IDLG_STATUS, NULL);     /*  (PBYTE)hWndParent);  */
  1023.                     
  1024.                     if (bit_flag.noconn)
  1025.                        {
  1026.                        WinShowWindow(hWndDbDlg,
  1027.                                   (BOOL)FALSE);
  1028.                    
  1029.                        WinDlgBox(HWND_DESKTOP, hWndDlg, (PFNWP)NO_CONMsgProc,
  1030.                                  0, IDLG_NO_CON, (PBYTE)hWndDlg);
  1031.  
  1032.                        WinShowWindow(hWndDbDlg,
  1033.                                    (BOOL)TRUE);
  1034.                        }
  1035.  
  1036.                     if (rc)
  1037.                        {
  1038.                        WinDismissDlg(hWndDlg, FALSE);
  1039.                        }
  1040.                     }
  1041.                  break;
  1042.  
  1043.             case DID_CANCEL: /* Button text: "Cancel"                      */
  1044.                  /* Ignore data values entered into the dialog controls    */
  1045.                  /* and dismiss the dialog window                          */
  1046.                  WinDestroyWindow(hWndDlg);
  1047.                  hWndDATABASE = 0;
  1048.                  break;
  1049.  
  1050.             case 259: /* Button text: "Help"                               */
  1051.                  break;
  1052.  
  1053.            }
  1054.          break; /* End of WM_COMMAND */
  1055.                                
  1056.     case WM_CLOSE:
  1057.          WinPostMsg(hWndDlg, WM_COMMAND, MPFROMSHORT(DID_CANCEL), 0L);
  1058.          break; /* End of WM_CLOSE */
  1059.            
  1060.     case WM_FAILEDVALIDATE:
  1061.          WinAlarm(HWND_DESKTOP, WA_ERROR);
  1062.          sfValidate = FALSE;
  1063.          WinSetFocus(HWND_DESKTOP, WinWindowFromID(hWndDlg, SHORT1FROMMP(mp1)));
  1064.          sfValidate = TRUE;
  1065.          return((MRESULT)TRUE);
  1066.          break; /* End of WM_FAILEDVALIDATE */
  1067.  
  1068.     default:
  1069.          return(WinDefDlgProc(hWndDlg, message, mp1, mp2));
  1070.          break;
  1071.    }
  1072.  return FALSE;
  1073. } /* End of DATABASEMsgProc */
  1074.  
  1075.  
  1076. /***************************************************************************/
  1077. /*                                                                         */
  1078. /* Dialog Window Procedure                                                 */
  1079. /*                                                                         */
  1080. /* This procedure is associated with the dialog box that is included in    */
  1081. /* the function name of the procedure. It provides the service routines    */
  1082. /* for the events (messages) that occur because the end user operates      */
  1083. /* one of the dialog box's buttons, entry fields, or controls.             */
  1084. /*                                                                         */
  1085. /* The SWITCH statement in the function distributes the dialog box         */
  1086. /* messages to the respective service routines, which are set apart by     */
  1087. /* the CASE clauses. Like any other PM window, the Dialog Window           */
  1088. /* procedures must provide an appropriate service routine for their end    */
  1089. /* user initiated messages as well as for the general PM messages (like    */
  1090. /* the WM_CLOSE message). If a message is sent to this procedure for       */
  1091. /* which there is no programmed CASE condition (no service routine),       */
  1092. /* the message is defaulted to the WinDefDlgProc function, where it is     */
  1093. /* disposed of by PM.                                                      */
  1094. /*                                                                         */
  1095. /***************************************************************************/
  1096.  
  1097. MRESULT EXPENTRY STATUSMsgProc(hWndDlg, message, mp1, mp2)
  1098. HWND hWndDlg;
  1099. USHORT message;
  1100. MPARAM mp1;
  1101. MPARAM mp2;
  1102. { 
  1103.  HPS hPS;              /* Handle for the Presentation Space              */
  1104.  RECTL rDlg;           /* Handle to rectangle formed by client area      */
  1105.  static SHORT sfValidate = TRUE;
  1106.  INT    i, j, k;
  1107.  static HWND  hWndParent;
  1108.  static HWND  hWndLBox;
  1109.  static USHORT cols[] = { 3, 70, 80, 9, 9, 9, 9, 9, 9, 9, 20, 9, 9, 9, 9, 9, 9, 9, 20, 9, 9, 9, 9, 9, 9, 9, 32, 28, 45 };
  1110.  char   sz_temp[9];
  1111.  char   *p_til;
  1112.  char   *p_colon;
  1113.  short  us_len;
  1114.  USHORT us_ret, us_ret_wch;
  1115.  PBYTE  p_stack;
  1116.  PBYTE  p_wch_stack;
  1117.           
  1118.  switch(message)
  1119.    {
  1120.     case WM_INITDLG:
  1121.  
  1122.          hWndParent = (HWND)mp2;
  1123.          cwCenter(hWndDlg, (HWND)hWndParent);
  1124.          hWndReFresh = hWndDlg;
  1125.          p_stack = stack;
  1126.          p_wch_stack = wch_stack;
  1127.          bit_flag.tend = FALSE;
  1128.  
  1129.     case WM_REDRAW:
  1130.  
  1131.          bit_flag.draw = TRUE;
  1132.          WinSendDlgItemMsg(hWndDlg, 256, LM_DELETEALL, 0L, 0L);
  1133.          WinSetPointer(HWND_DESKTOP,
  1134.              WinQuerySysPointer(HWND_DESKTOP,SPTR_WAIT,FALSE));
  1135.  
  1136.          bit_flag.time = FALSE;
  1137.          us_ret_wch = _beginthread((PVOID)wch_thread,
  1138.                                   p_wch_stack,
  1139.                                   STACK_SIZE,
  1140.                                   ARGS);
  1141.  
  1142.          us_db_count = 1;
  1143.          SQLGOPST(3, 1, strlen(sz_dbase), &sz_dbase, &us_db_count,
  1144.                                           &basestat, &sqlca);
  1145.  
  1146.          if (sqlca.sqlcode != 0)
  1147.             {
  1148.             db_crash();
  1149.             }
  1150.  
  1151.          if (!bit_flag.none)
  1152.             {
  1153.             write_db_stats();
  1154.             }
  1155.  
  1156.          if (basestat.connects == 0)
  1157.             {
  1158.             bit_flag.noconn = TRUE;
  1159.  
  1160.             SQLGFREE(&sqlca);
  1161.             if (sqlca.sqlcode != 0)
  1162.                {
  1163.                db_crash();
  1164.                }
  1165.  
  1166.             WinDismissDlg(hWndDlg, FALSE);
  1167.             }
  1168.          else
  1169.             {
  1170.             SQLGUSER(strlen(sz_dbase), &sz_dbase, &basestat.ustat, &sqlca);
  1171.             if ((sqlca.sqlcode != 0) && (sqlca.sqlcode != -1203))
  1172.                {
  1173.                db_crash();
  1174.                }
  1175.  
  1176.             SQLGFREE(&sqlca);
  1177.             if (sqlca.sqlcode != 0)
  1178.                {
  1179.                db_crash();
  1180.                }
  1181.  
  1182.             bit_flag.time = TRUE;
  1183.             sort_users();
  1184.  
  1185.             if (!bit_flag.none)
  1186.                {
  1187.                write_user_stats();
  1188.                fclose(spyfile);
  1189.                }
  1190.  
  1191.             if (basestat.location == 'R')
  1192.                {
  1193.                strcpy(sz_title, "Remote: ");
  1194.                }
  1195.             else
  1196.                {
  1197.                strcpy(sz_title, "Local: ");
  1198.                }
  1199.  
  1200.             strncat(sz_title, basestat.db_name, 8);
  1201.             strcat(sz_title, "  Alias: ");
  1202.             strncat(sz_title, basestat.db_alias, 8);
  1203.  
  1204.             if (basestat.location == 'R')
  1205.                {
  1206.                strcat(sz_title, "  Node: ");
  1207.                strncat(sz_title, basestat.node, 8);
  1208.                }
  1209.  
  1210.             strcat(sz_title, "  Connects: ");
  1211.             itoa(basestat.connects, sz_conn, 10);
  1212.             strcat(sz_title, sz_conn);
  1213.  
  1214.             WinSetWindowText(hWndDlg, sz_title);
  1215.     
  1216.             for(j=0;j<basestat.connects;j++)
  1217.                {
  1218.                memset(sz_trans_con, '\0', sizeof(sz_trans_con));
  1219.                memset(sz_req_con, '\0', sizeof(sz_req_con));
  1220.                memset(sz_req_cur, '\0', sizeof(sz_req_cur));
  1221.                memset(sz_temp, '\0', sizeof(sz_temp));
  1222.                memset(sz_stats, '\0', sizeof(sz_stats));
  1223.  
  1224.                ltoa(basestat.ustat[j].con_trans, sz_trans_con, 10);
  1225.                ltoa(basestat.ustat[j].con_reqs, sz_req_con, 10);
  1226.                ltoa(basestat.ustat[j].cur_reqs, sz_req_cur, 10);
  1227.  
  1228.                strcpy(sz_temp, sz_trans_con);
  1229.                us_len = strlen(sz_trans_con);
  1230.  
  1231.                for(k=0;k<(8 - us_len);k++)
  1232.                   {
  1233.                   sz_trans_con[k] = ' ';
  1234.                   }
  1235.  
  1236.                strcat(sz_trans_con, sz_temp);
  1237.                sz_trans_con[8] = '\0';
  1238.       
  1239.                strcpy(sz_temp, sz_req_con);
  1240.                us_len = strlen(sz_req_con);
  1241.  
  1242.                for(k=0;k<(8 - us_len);k++)
  1243.                   {
  1244.                   sz_req_con[k] = ' ';
  1245.                   }
  1246.  
  1247.                strcat(sz_req_con, sz_temp);
  1248.                sz_req_con[8] = '\0';
  1249.  
  1250.  
  1251.                strcpy(sz_temp, sz_req_cur);
  1252.                us_len = strlen(sz_req_cur);
  1253.  
  1254.                for(k=0;k<(8 - us_len);k++)
  1255.                   {
  1256.                   sz_req_cur[k] = ' ';
  1257.                   }
  1258.  
  1259.                strcat(sz_req_cur, sz_temp);
  1260.                sz_req_cur[8] = '\0';
  1261.  
  1262.  
  1263.                strcpy(sz_stats, "~");
  1264.                strncat(sz_stats, basestat.ustat[j].authid, 8);
  1265.                strcat(sz_stats, "~");
  1266.                strncat(sz_stats, basestat.ustat[j].node, 8);
  1267.                strcat(sz_stats, "~");
  1268.  
  1269.                if (( p_til = strrchr(sz_stats, '~')) != NULL)
  1270.                   {
  1271.                   p_til++;
  1272.                   for(k=0;k<strlen(sz_trans_con);k++)
  1273.                      {
  1274.                      *p_til = sz_trans_con[k];
  1275.                      p_til++;
  1276.                      *p_til = '~';
  1277.                      p_til++;
  1278.                      }
  1279.                   }
  1280.  
  1281.                if (( p_til = strrchr(sz_stats, '~')) != NULL)
  1282.                   {
  1283.                   p_til++;
  1284.                   for(k=0;k<strlen(sz_req_con);k++)
  1285.                      {
  1286.                      *p_til = sz_req_con[k];
  1287.                      p_til++;
  1288.                      *p_til = '~';
  1289.                      p_til++;
  1290.                      }
  1291.                   }
  1292.  
  1293.                if (( p_til = strrchr(sz_stats, '~')) != NULL)
  1294.                   {
  1295.                   p_til++;
  1296.                   for(k=0;k<strlen(sz_req_cur);k++)
  1297.                      {
  1298.                      *p_til = sz_req_cur[k];
  1299.                      p_til++;
  1300.                      *p_til = '~';
  1301.                      p_til++;
  1302.                      }
  1303.                   }
  1304.  
  1305.                if (basestat.ustat[j].trans_state == 'S')
  1306.                   {
  1307.                   strcat(sz_stats, "S");
  1308.                   }
  1309.  
  1310.                if (basestat.ustat[j].trans_state == 'R')
  1311.                   {
  1312.                   strcat(sz_stats, "R");
  1313.                   }
  1314.  
  1315.                if (basestat.ustat[j].trans_state == 'C')
  1316.                   {
  1317.                   strcat(sz_stats, "C");
  1318.                   }
  1319.  
  1320.                strcat(sz_stats, "~");
  1321.  
  1322.                if (basestat.ustat[j].lock_state == 'N')
  1323.                   {
  1324.                   strcat(sz_stats, "N");
  1325.                   }
  1326.  
  1327.                if (basestat.ustat[j].lock_state == 'W')
  1328.                   {
  1329.                   strcat(sz_stats, "W");
  1330.                   }
  1331.  
  1332.                get_time();
  1333.  
  1334.                con_time = bintime - basestat.ustat[j].connect_time;
  1335.                out_time = localtime(&con_time);
  1336.                sprintf(sz_time_out, "%s", asctime(out_time));
  1337.                p_colon = strchr(sz_time_out, ':');
  1338.                p_colon--;
  1339.                p_colon--;
  1340.                strcat(sz_stats, "~");
  1341.                strncat(sz_stats, p_colon, 8);
  1342.  
  1343.                WinSendDlgItemMsg(hWndDlg,
  1344.                                      256,
  1345.                            LM_INSERTITEM,
  1346.                  MPFROM2SHORT(LIT_END,0),
  1347.                       MPFROMP(sz_stats));
  1348.  
  1349.                } /* end of for j */
  1350.             }
  1351.  
  1352.          WinSetPointer(HWND_DESKTOP,
  1353.             WinQuerySysPointer(HWND_DESKTOP,SPTR_ARROW,FALSE));
  1354.  
  1355.          if (message == WM_INITDLG)
  1356.             {
  1357.             us_ret = _beginthread((PVOID)refresh_thread,
  1358.                                   p_stack,
  1359.                                   STACK_SIZE,
  1360.                                   ARGS);
  1361.             }
  1362.  
  1363.          bit_flag.draw = FALSE;
  1364.  
  1365.          break; /* End of WM_INITDLG  and WM_REDRAW */
  1366.    
  1367.         case WM_MEASUREITEM:
  1368.                 return( LimitLBox( hWndDlg, 1750 ) );
  1369.             break;
  1370.  
  1371.         case WM_DRAWITEM:
  1372.             if ( SHORT1FROMMP( mp1 ) != 256)
  1373.                { 
  1374.                return ( 0L );
  1375.                }
  1376.  
  1377.             return( AlignLBox( hWndDlg, 256, cols, mp2 ) );
  1378.             break;
  1379.    
  1380.     case WM_CONTROL:
  1381.          switch(SHORT1FROMMP(mp1))
  1382.            {
  1383.             case 256: /* List box                                          */
  1384.                  {
  1385.                  }
  1386.                  break;
  1387.  
  1388.            }
  1389.          break; /* End of WM_CONTROL */
  1390.    
  1391.     case WM_COMMAND:
  1392.          switch(SHORT1FROMMP(mp1))
  1393.            {
  1394.             case DID_OK: /* Button text: "Ok"                              */
  1395.  
  1396.                  WinShowWindow(hWndDbDlg,
  1397.                              (BOOL)FALSE);
  1398.  
  1399.                  WinDismissDlg(hWndDlg, TRUE);
  1400.                  break;
  1401.  
  1402.             case DID_CANCEL: /* Button text: "Cancel"                      */
  1403.                  /* Ignore data values entered into the dialog controls    */
  1404.                  /* and dismiss the dialog window                          */
  1405.                  bit_flag.tend = TRUE;
  1406.                  WinDismissDlg(hWndDlg, FALSE);
  1407.                  break;
  1408.  
  1409.             case 257: /* Button text: "Help"                               */
  1410.                  break;
  1411.  
  1412.            }
  1413.          break; /* End of WM_COMMAND */
  1414.                                
  1415. //    case WM_PAINT:    /* code for the window's client area               */
  1416. //         /* Obtain a handle to a cache presentation space                */
  1417. //
  1418. //         hWndLBox = WinWindowFromID(hWndDlg, 256);
  1419. //
  1420. //         hPS = WinBeginPaint(hWndLBox, 0, 0);
  1421. //
  1422. //         /* Determine the size of the client area                        */
  1423. //         WinQueryWindowRect(hWndLBox, &rDlg);
  1424. //
  1425. //         /* Fill the background with the default background color        */
  1426. //         WinFillRect(hPS, &rDlg, CLR_BLUE);
  1427. //
  1428. //         /* return presentation space to state before WinBeginPaint      */
  1429. //         WinEndPaint(hPS);
  1430. //         break; /* End of WM_PAINT */
  1431.                                
  1432.     case WM_CLOSE:
  1433.          WinPostMsg(hWndDlg, WM_COMMAND, MPFROMSHORT(DID_CANCEL), 0L);
  1434.          break; /* End of WM_CLOSE */
  1435.            
  1436.     case WM_FAILEDVALIDATE:
  1437.          WinAlarm(HWND_DESKTOP, WA_ERROR);
  1438.          sfValidate = FALSE;
  1439.          WinSetFocus(HWND_DESKTOP, WinWindowFromID(hWndDlg, SHORT1FROMMP(mp1)));
  1440.          sfValidate = TRUE;
  1441.          return((MRESULT)TRUE);
  1442.          break; /* End of WM_FAILEDVALIDATE */
  1443.  
  1444.     default:
  1445.          return(WinDefDlgProc(hWndDlg, message, mp1, mp2));
  1446.          break;
  1447.    }
  1448.  return FALSE;
  1449. } /* End of STATUSMsgProc */
  1450.  
  1451.  
  1452. /***************************************************************************/
  1453. /*                                                                         */
  1454. /* Dialog Window Procedure                                                 */
  1455. /*                                                                         */
  1456. /* This procedure is associated with the dialog box that is included in    */
  1457. /* the function name of the procedure. It provides the service routines    */
  1458. /* for the events (messages) that occur because the end user operates      */
  1459. /* one of the dialog box's buttons, entry fields, or controls.             */
  1460. /*                                                                         */
  1461. /* The SWITCH statement in the function distributes the dialog box         */
  1462. /* messages to the respective service routines, which are set apart by     */
  1463. /* the CASE clauses. Like any other PM window, the Dialog Window           */
  1464. /* procedures must provide an appropriate service routine for their end    */
  1465. /* user initiated messages as well as for the general PM messages (like    */
  1466. /* the WM_CLOSE message). If a message is sent to this procedure for       */
  1467. /* which there is no programmed CASE condition (no service routine),       */
  1468. /* the message is defaulted to the WinDefDlgProc function, where it is     */
  1469. /* disposed of by PM.                                                      */
  1470. /*                                                                         */
  1471. /***************************************************************************/
  1472.  
  1473. MRESULT EXPENTRY CATMsgProc(hWndDlg, message, mp1, mp2)
  1474. HWND hWndDlg;
  1475. USHORT message;
  1476. MPARAM mp1;
  1477. MPARAM mp2;
  1478. { 
  1479.  static SHORT sfValidate = TRUE;
  1480.  INT           i, us_item_index, us_item_len;
  1481.  INT           us_node_index;
  1482.  static HWND  hWndParent;
  1483.  CATStruct FAR *Cat;
  1484.  static USHORT rc;
  1485.  char          *pspace;
  1486.  static char   ch_type; 
  1487.  static char   ch_drive;
  1488.           
  1489.  switch(message)
  1490.    {
  1491.     case WM_INITDLG:
  1492.          Cat = (CATStruct FAR *)WinQueryWindowULong(hWndClient, OFFSET_CAT);
  1493.          memset(sz_rds_name, '\0', sizeof(sz_rds_name));
  1494.          hWndParent = (HWND)mp2;
  1495.          cwCenter(hWndDlg, (HWND)hWndParent);
  1496.          /* Initialize radio button control: YourWindowsTitleGoesHere      */
  1497.          WinPostMsg(hWndDlg, WM_CONTROL,
  1498.                     MPFROMSHORT(Cat->YourWindowsTitleGoesHere), 0L);
  1499.  
  1500.          WinSendDlgItemMsg(hWndDlg, 262, EM_SETTEXTLIMIT, (MPARAM)8, NULL);
  1501.          WinSendDlgItemMsg(hWndDlg, 263, EM_SETTEXTLIMIT, (MPARAM)8, NULL);
  1502.          WinSendDlgItemMsg(hWndDlg, 264, EM_SETTEXTLIMIT, (MPARAM)30, NULL);
  1503.          WinSendDlgItemMsg(hWndDlg, 270, EM_SETTEXTLIMIT, (MPARAM)1, NULL);
  1504.  
  1505.          SQLGNOPS(&us_hand_node, &us_count_node, &sqlca);
  1506.  
  1507.          strcpy(sz_node[0], "--New--");
  1508.  
  1509.          for(i=1;i<us_count_node+1;i++)
  1510.             {
  1511.             SQLGNGNE(us_hand_node, &st_node, &sqlca);
  1512.             strncpy(sz_node[i], st_node->nodename, 8);
  1513.             sz_node[i][8] = '\0';
  1514.             }
  1515.  
  1516.          SQLGNCLS(us_hand_node, &sqlca);
  1517.  
  1518.          for(i=0;i<us_count_node+1;i++)
  1519.             {
  1520.             WinSendDlgItemMsg(hWndDlg,
  1521.                                   265,
  1522.                         LM_INSERTITEM,
  1523.               MPFROM2SHORT(LIT_END,0),
  1524.                 MPFROMP(sz_node[i]));
  1525.             }
  1526.  
  1527.          break; /* End of WM_INITDLG */
  1528.    
  1529.     case WM_CONTROL:
  1530.          switch(SHORT1FROMMP(mp1))
  1531.            {
  1532.             case 256: /* Radiobutton text: "Local"                         */
  1533.                  cwCheckDlgItem(hWndDlg, 256, TRUE);
  1534.                  cwCheckDlgItem(hWndDlg, 257, FALSE);
  1535.                  ch_type = '0';
  1536.                  ch_drive = '\0';
  1537.                  break;
  1538.  
  1539.             case 257: /* Radiobutton text: "Remote"                        */
  1540.                  cwCheckDlgItem(hWndDlg, 257, TRUE);
  1541.                  cwCheckDlgItem(hWndDlg, 256, FALSE);
  1542.                  ch_type = '1';
  1543.                  ch_drive = '\0';
  1544.                  break;
  1545.  
  1546.             case 262: /* Entry field                                       */
  1547.                  switch(SHORT2FROMMP(mp1)) /* switch on Notification Code  */
  1548.                    { 
  1549.                     case EN_SETFOCUS:/* Entry field is receiving the focus */
  1550.                          break;
  1551.  
  1552.                     case EN_KILLFOCUS: /* Entry field is losing the focus  */
  1553.                          break;
  1554.  
  1555.                     default: /* Default other messages                     */
  1556.                          return(WinDefDlgProc(hWndDlg, message, mp1, mp2));
  1557.                          break;
  1558.                    }
  1559.                  break;
  1560.  
  1561.             case 263: /* Entry field                                       */
  1562.                  switch(SHORT2FROMMP(mp1)) /* switch on Notification Code  */
  1563.                    { 
  1564.                     case EN_SETFOCUS:/* Entry field is receiving the focus */
  1565.                          break;
  1566.  
  1567.                     case EN_KILLFOCUS: /* Entry field is losing the focus  */
  1568.                          break;
  1569.  
  1570.                     default: /* Default other messages                     */
  1571.                          return(WinDefDlgProc(hWndDlg, message, mp1, mp2));
  1572.                          break;
  1573.                    }
  1574.                  break;
  1575.  
  1576.             case 264: /* Entry field                                       */
  1577.                  switch(SHORT2FROMMP(mp1)) /* switch on Notification Code  */
  1578.                    { 
  1579.                     case EN_SETFOCUS:/* Entry field is receiving the focus */
  1580.                          break;
  1581.  
  1582.                     case EN_KILLFOCUS: /* Entry field is losing the focus  */
  1583.                          break;
  1584.  
  1585.                     default: /* Default other messages                     */
  1586.                          return(WinDefDlgProc(hWndDlg, message, mp1, mp2));
  1587.                          break;
  1588.                    }
  1589.                  break;
  1590.  
  1591.             case 270: /* Entry field                                       */
  1592.                  switch(SHORT2FROMMP(mp1)) /* switch on Notification Code  */
  1593.                    { 
  1594.                     case EN_SETFOCUS:/* Entry field is receiving the focus */
  1595.                          break;
  1596.  
  1597.                     case EN_KILLFOCUS: /* Entry field is losing the focus  */
  1598.                          break;
  1599.  
  1600.                     default: /* Default other messages                     */
  1601.                          return(WinDefDlgProc(hWndDlg, message, mp1, mp2));
  1602.                          break;
  1603.                    }
  1604.                  break;
  1605.  
  1606.             case 265: /* List box                                          */
  1607.                  {
  1608.                  us_node_index = (USHORT)WinSendDlgItemMsg(hWndDlg,
  1609.                                                                265,
  1610.                                                  LM_QUERYSELECTION,
  1611.                                                        (short)NULL,
  1612.                                                       (short)NULL);
  1613.                        
  1614.                   if (us_node_index == LIT_NONE)
  1615.                     {
  1616.                     strcpy(sz_rds_name,"--New--");
  1617.                     }
  1618.                  else
  1619.                     {
  1620.                     strcpy(sz_rds_name, sz_node[us_node_index]);
  1621.  
  1622.                     if ((pspace = strchr(sz_rds_name, ' ')) != NULL)
  1623.                        {
  1624.                        *pspace = '\0';
  1625.                        }
  1626.  
  1627.                     sz_rds_name[8] = '\0';
  1628.                     }
  1629.                  }
  1630.                  break;
  1631.            }
  1632.          break; /* End of WM_CONTROL */
  1633.    
  1634.     case WM_COMMAND:
  1635.          switch(SHORT1FROMMP(mp1))
  1636.            {
  1637.             case DID_OK: /* Button text: "Ok"                              */
  1638.                   Cat = (CATStruct FAR *)WinQueryWindowULong(hWndClient, OFFSET_CAT);
  1639.                  /* Query radio button for current state, if set then      */
  1640.                  /* set the dialog structure variable to the control ID    */
  1641.                  if (WinSendDlgItemMsg(hWndDlg, 256,
  1642.                                BM_QUERYCHECK, 0L, 0L ))
  1643.                     Cat->YourWindowsTitleGoesHere = 256;
  1644.                  /* Query radio button for current state, if set then      */
  1645.                  /* set the dialog structure variable to the control ID    */
  1646.                  if (WinSendDlgItemMsg(hWndDlg, 257,
  1647.                                BM_QUERYCHECK, 0L, 0L ))
  1648.                     Cat->YourWindowsTitleGoesHere = 257;
  1649.  
  1650.                  if ((strcmp(sz_rds_name, "--New--")) == 0)
  1651.                     {
  1652.                     rc = WinDlgBox(HWND_DESKTOP, hWndDlg,
  1653.                            (PFNWP)NODEMsgProc,
  1654.                            0, IDLG_NODE, (PBYTE)hWndParent);
  1655.  
  1656.                     if (rc)
  1657.                        {
  1658.                         WinSendDlgItemMsg(hWndDlg,
  1659.                                               265,
  1660.                                     LM_INSERTITEM,
  1661.                           MPFROM2SHORT(LIT_END,0),
  1662.                            MPFROMP(sz_node[us_count_node]));
  1663.                        }
  1664.  
  1665.                     break;
  1666.  
  1667.                     }
  1668.  
  1669.                  us_count_dir++;
  1670.  
  1671.                  memset(sz_comment, '\0', sizeof(sz_comment));
  1672.                  memset(sz_db_entry, '\0', sizeof(sz_db_entry));
  1673.                  memset(sz_alias[us_count_dir], '\0',
  1674.                         sizeof(sz_alias[us_count_dir]));
  1675.  
  1676.                  bit_flag.cat = TRUE;
  1677.  
  1678.                  WinQueryDlgItemText(hWndDlg, 262,
  1679.                                      sizeof(sz_db_entry),
  1680.                                      sz_db_entry);
  1681.  
  1682.                  if ((pspace = strrchr(sz_db_entry, ' ')) != NULL)
  1683.                     {
  1684.                     *pspace = '\0';
  1685.                     }
  1686.  
  1687.                  if (sz_db_entry[0] == 0)
  1688.                     {
  1689.                     DosBeep(500,750);
  1690.                     bit_flag.cat = FALSE;
  1691.                     }
  1692.                  else
  1693.                     {
  1694.                     strcpy(sz_dbase, sz_db_entry);
  1695.                     sz_dbase[8] = '\0';
  1696.                     }
  1697.  
  1698.                  strupr(sz_dbase);
  1699.  
  1700.                  WinQueryDlgItemText(hWndDlg, 263,
  1701.                                      sizeof(sz_alias[us_count_dir]),
  1702.                                      sz_alias[us_count_dir]);
  1703.  
  1704.                  if ((pspace = strrchr(sz_alias[us_count_dir], ' ')) != NULL)
  1705.                     {
  1706.                     *pspace = '\0';
  1707.                     }
  1708.  
  1709.                  if (sz_alias[us_count_dir][0] == 0)
  1710.                     {
  1711.                     DosBeep(500,250);
  1712.                     bit_flag.cat = FALSE;
  1713.                     }
  1714.  
  1715.                  strupr(sz_alias[us_count_dir]);
  1716.  
  1717.                  WinQueryDlgItemText(hWndDlg, 264,
  1718.                                      sizeof(sz_comment),
  1719.                                      sz_comment);
  1720.  
  1721. /*
  1722.                  us_node_index = (USHORT)WinSendDlgItemMsg(hWndDlg, 265,
  1723.                      LM_QUERYSELECTION, 0L, 0L);
  1724.  
  1725.                  if (ch_type == '1')
  1726.                     {
  1727.                     strcpy(sz_rds_name, sz_node[us_node_index]);
  1728.                     }
  1729. */
  1730.                  if (bit_flag.cat)
  1731.                     {
  1732.                     SQLGCATD(strlen(sz_comment), 
  1733.                              strlen(sz_rds_name),
  1734.                              strlen(sz_alias[us_count_dir]),
  1735.                              strlen(sz_dbase),
  1736.                              ch_drive,
  1737.                              0,
  1738.                              ch_type,
  1739.                              &sqlca,
  1740.                              sz_comment,
  1741.                              sz_rds_name,
  1742.                              sz_alias[us_count_dir],
  1743.                              sz_dbase);
  1744.  
  1745.                     if (sqlca.sqlcode != 0)
  1746.                        {
  1747.                        DosBeep(500,500);
  1748.                        }
  1749.  
  1750.                  WinDismissDlg(hWndDlg, TRUE);
  1751.                     }
  1752.                  else
  1753.                     {
  1754.                     us_count_dir--;
  1755.                     }
  1756.  
  1757.                  break;
  1758.  
  1759.             case DID_CANCEL: /* Button text: "Cancel"                      */
  1760.                  /* Ignore data values entered into the dialog controls    */
  1761.                  /* and dismiss the dialog window                          */
  1762.                  WinDismissDlg(hWndDlg, FALSE);
  1763.                  break;
  1764.  
  1765.             case 268: /* Button text: "Help"                               */
  1766.                  break;
  1767.  
  1768.            }
  1769.          break; /* End of WM_COMMAND */
  1770.                                
  1771.     case WM_CLOSE:
  1772.          WinPostMsg(hWndDlg, WM_COMMAND, MPFROMSHORT(DID_CANCEL), 0L);
  1773.          break; /* End of WM_CLOSE */
  1774.            
  1775.     case WM_FAILEDVALIDATE:
  1776.          WinAlarm(HWND_DESKTOP, WA_ERROR);
  1777.          sfValidate = FALSE;
  1778.          WinSetFocus(HWND_DESKTOP, WinWindowFromID(hWndDlg, SHORT1FROMMP(mp1)));
  1779.          sfValidate = TRUE;
  1780.          return((MRESULT)TRUE);
  1781.          break; /* End of WM_FAILEDVALIDATE */
  1782.  
  1783.     default:
  1784.          return(WinDefDlgProc(hWndDlg, message, mp1, mp2));
  1785.          break;
  1786.    }
  1787.  return FALSE;
  1788. } /* End of CATMsgProc */
  1789.  
  1790.  
  1791. /***************************************************************************/
  1792. /*                                                                         */
  1793. /* Dialog Window Procedure                                                 */
  1794. /*                                                                         */
  1795. /* This procedure is associated with the dialog box that is included in    */
  1796. /* the function name of the procedure. It provides the service routines    */
  1797. /* for the events (messages) that occur because the end user operates      */
  1798. /* one of the dialog box's buttons, entry fields, or controls.             */
  1799. /*                                                                         */
  1800. /* The SWITCH statement in the function distributes the dialog box         */
  1801. /* messages to the respective service routines, which are set apart by     */
  1802. /* the CASE clauses. Like any other PM window, the Dialog Window           */
  1803. /* procedures must provide an appropriate service routine for their end    */
  1804. /* user initiated messages as well as for the general PM messages (like    */
  1805. /* the WM_CLOSE message). If a message is sent to this procedure for       */
  1806. /* which there is no programmed CASE condition (no service routine),       */
  1807. /* the message is defaulted to the WinDefDlgProc function, where it is     */
  1808. /* disposed of by PM.                                                      */
  1809. /*                                                                         */
  1810. /***************************************************************************/
  1811.  
  1812. MRESULT EXPENTRY NODEMsgProc(hWndDlg, message, mp1, mp2)
  1813. HWND hWndDlg;
  1814. USHORT message;
  1815. MPARAM mp1;
  1816. MPARAM mp2;
  1817. { 
  1818.  static SHORT sfValidate = TRUE;
  1819.  INT    i;
  1820.  static HWND  hWndParent;
  1821.  char         *pspace;
  1822.           
  1823.  switch(message)
  1824.    {
  1825.     case WM_INITDLG:
  1826.          hWndParent = (HWND)mp2;
  1827.          cwCenter(hWndDlg, (HWND)hWndParent);
  1828.  
  1829.          WinSendDlgItemMsg(hWndDlg, 261, EM_SETTEXTLIMIT, (MPARAM)8, NULL);
  1830.          WinSendDlgItemMsg(hWndDlg, 262, EM_SETTEXTLIMIT, (MPARAM)8, NULL);
  1831.          WinSendDlgItemMsg(hWndDlg, 263, EM_SETTEXTLIMIT, (MPARAM)8, NULL);
  1832.          WinSendDlgItemMsg(hWndDlg, 264, EM_SETTEXTLIMIT, (MPARAM)8, NULL);
  1833.          WinSendDlgItemMsg(hWndDlg, 265, EM_SETTEXTLIMIT, (MPARAM)30, NULL);
  1834.  
  1835.          break; /* End of WM_INITDLG */
  1836.    
  1837.     case WM_CONTROL:
  1838.          switch(SHORT1FROMMP(mp1))
  1839.            {
  1840.             case 261: /* Entry field                                       */
  1841.                  switch(SHORT2FROMMP(mp1)) /* switch on Notification Code  */
  1842.                    { 
  1843.                     case EN_SETFOCUS:/* Entry field is receiving the focus */
  1844.                          break;
  1845.  
  1846.                     case EN_KILLFOCUS: /* Entry field is losing the focus  */
  1847.                          break;
  1848.  
  1849.                     default: /* Default other messages                     */
  1850.                          return(WinDefDlgProc(hWndDlg, message, mp1, mp2));
  1851.                          break;
  1852.                    }
  1853.                  break;
  1854.  
  1855.             case 262: /* Entry field                                       */
  1856.                  switch(SHORT2FROMMP(mp1)) /* switch on Notification Code  */
  1857.                    { 
  1858.                     case EN_SETFOCUS:/* Entry field is receiving the focus */
  1859.                          break;
  1860.  
  1861.                     case EN_KILLFOCUS: /* Entry field is losing the focus  */
  1862.                          break;
  1863.  
  1864.                     default: /* Default other messages                     */
  1865.                          return(WinDefDlgProc(hWndDlg, message, mp1, mp2));
  1866.                          break;
  1867.                    }
  1868.                  break;
  1869.  
  1870.             case 263: /* Entry field                                       */
  1871.                  switch(SHORT2FROMMP(mp1)) /* switch on Notification Code  */
  1872.                    { 
  1873.                     case EN_SETFOCUS:/* Entry field is receiving the focus */
  1874.                          break;
  1875.  
  1876.                     case EN_KILLFOCUS: /* Entry field is losing the focus  */
  1877.                          break;
  1878.  
  1879.                     default: /* Default other messages                     */
  1880.                          return(WinDefDlgProc(hWndDlg, message, mp1, mp2));
  1881.                          break;
  1882.                    }
  1883.                  break;
  1884.  
  1885.             case 264: /* Entry field                                       */
  1886.                  switch(SHORT2FROMMP(mp1)) /* switch on Notification Code  */
  1887.                    { 
  1888.                     case EN_SETFOCUS:/* Entry field is receiving the focus */
  1889.                          break;
  1890.  
  1891.                     case EN_KILLFOCUS: /* Entry field is losing the focus  */
  1892.                          break;
  1893.  
  1894.                     default: /* Default other messages                     */
  1895.                          return(WinDefDlgProc(hWndDlg, message, mp1, mp2));
  1896.                          break;
  1897.                    }
  1898.                  break;
  1899.  
  1900.             case 265: /* Entry field                                       */
  1901.                  switch(SHORT2FROMMP(mp1)) /* switch on Notification Code  */
  1902.                    { 
  1903.                     case EN_SETFOCUS:/* Entry field is receiving the focus */
  1904.                          break;
  1905.  
  1906.                     case EN_KILLFOCUS: /* Entry field is losing the focus  */
  1907.                          break;
  1908.  
  1909.                     default: /* Default other messages                     */
  1910.                          return(WinDefDlgProc(hWndDlg, message, mp1, mp2));
  1911.                          break;
  1912.                    }
  1913.                  break;
  1914.  
  1915.            }
  1916.          break; /* End of WM_CONTROL */
  1917.    
  1918.     case WM_COMMAND:
  1919.          switch(SHORT1FROMMP(mp1))
  1920.            {
  1921.             case DID_OK: /* Button text: "Ok"                              */
  1922.  
  1923.                  us_count_node++;
  1924.  
  1925.                  memset(sz_comment, '\0', sizeof(sz_comment));
  1926.                  memset(sz_node[us_count_node], '\0', sizeof(sz_node[us_count_node]));
  1927.                  memset(sz_partner_lu, '\0', sizeof(sz_partner_lu));
  1928.                  memset(sz_local_lu, '\0', sizeof(sz_local_lu));
  1929.                  memset(sz_mode, '\0', sizeof(sz_mode));
  1930.  
  1931.                  bit_flag.node = TRUE;
  1932.      
  1933.                  WinQueryDlgItemText(hWndDlg, 261,
  1934.                                      sizeof(sz_mode),
  1935.                                      sz_mode);
  1936.  
  1937.                  if ((pspace = strrchr(sz_mode, ' ')) != NULL)
  1938.                     {
  1939.                     *pspace = '\0';
  1940.                     }
  1941.  
  1942.                  if (sz_mode[0] == 0)
  1943.                     {
  1944.                     DosBeep(200,500);
  1945.                     bit_flag.node = FALSE;
  1946.                     }
  1947.  
  1948.                  WinQueryDlgItemText(hWndDlg, 262,
  1949.                                      sizeof(sz_local_lu),
  1950.                                      sz_local_lu);
  1951.  
  1952.                  if ((pspace = strrchr(sz_local_lu, ' ')) != NULL)
  1953.                     {
  1954.                     *pspace = '\0';
  1955.                     }
  1956.  
  1957.                  if (sz_local_lu == 0)
  1958.                     {
  1959.                     DosBeep(500,250);
  1960.                     bit_flag.node = FALSE;
  1961.                     }
  1962.  
  1963.                  WinQueryDlgItemText(hWndDlg, 263,
  1964.                                      sizeof(sz_partner_lu),
  1965.                                      sz_partner_lu);
  1966.  
  1967.                  if ((pspace = strrchr(sz_partner_lu, ' ')) != NULL)
  1968.                     {
  1969.                     *pspace = '\0';
  1970.                     }
  1971.  
  1972.                  if (sz_partner_lu == 0)
  1973.                     {
  1974.                     DosBeep(500,250);
  1975.                     bit_flag.node = FALSE;
  1976.                     }
  1977.  
  1978.                  WinQueryDlgItemText(hWndDlg, 264,
  1979.                                      sizeof(sz_node[us_count_node]),
  1980.                                      sz_node[us_count_node]);
  1981.  
  1982.                  if ((pspace = strrchr(sz_nodename, ' ')) != NULL)
  1983.                     {
  1984.                     *pspace = '\0';
  1985.                     }
  1986.  
  1987.                  if (sz_node[us_count_node][0] == 0)
  1988.                     {
  1989.                     DosBeep(500,250);
  1990.                     bit_flag.node = FALSE;
  1991.                     }
  1992.  
  1993.                  WinQueryDlgItemText(hWndDlg, 265,
  1994.                                      sizeof(sz_comment),
  1995.                                      sz_comment);
  1996.  
  1997.                  if ((pspace = strrchr(sz_comment, ' ')) != NULL)
  1998.                     {
  1999.                     *pspace = '\0';
  2000.                     }
  2001.  
  2002.                  if (bit_flag.node)
  2003.                     {
  2004.                     SQLGCATN(strlen(sz_comment), 
  2005.                              strlen(sz_mode),
  2006.                              strlen(sz_partner_lu),
  2007.                              strlen(sz_local_lu),
  2008.                              strlen(sz_node[us_count_node]),
  2009.                              0,
  2010.                              &sqlca,
  2011.                              sz_comment,
  2012.                              sz_mode,
  2013.                              sz_partner_lu,
  2014.                              sz_local_lu,
  2015.                              sz_node[us_count_node]);
  2016.  
  2017.                     if (sqlca.sqlcode != 0)
  2018.                        {
  2019.                        DosBeep(500,500);
  2020.                        }
  2021.                     }
  2022.  
  2023.                  WinDismissDlg(hWndDlg, TRUE);
  2024.                  break;
  2025.  
  2026.             case DID_CANCEL: /* Button text: "Cancel"                      */
  2027.                  /* Ignore data values entered into the dialog controls    */
  2028.                  /* and dismiss the dialog window                          */
  2029.                  WinDismissDlg(hWndDlg, FALSE);
  2030.                  break;
  2031.  
  2032.             case 268: /* Button text: "Help"                               */
  2033.                  break;
  2034.  
  2035.            }
  2036.          break; /* End of WM_COMMAND */
  2037.                                
  2038.     case WM_CLOSE:
  2039.          WinPostMsg(hWndDlg, WM_COMMAND, MPFROMSHORT(DID_CANCEL), 0L);
  2040.          break; /* End of WM_CLOSE */
  2041.            
  2042.     case WM_FAILEDVALIDATE:
  2043.          WinAlarm(HWND_DESKTOP, WA_ERROR);
  2044.          sfValidate = FALSE;
  2045.          WinSetFocus(HWND_DESKTOP, WinWindowFromID(hWndDlg, SHORT1FROMMP(mp1)));
  2046.          sfValidate = TRUE;
  2047.          return((MRESULT)TRUE);
  2048.          break; /* End of WM_FAILEDVALIDATE */
  2049.  
  2050.     default:
  2051.          return(WinDefDlgProc(hWndDlg, message, mp1, mp2));
  2052.          break;
  2053.    }
  2054.  return FALSE;
  2055. } /* End of NODEMsgProc */
  2056.  
  2057.  
  2058. /***************************************************************************/
  2059. /*                                                                         */
  2060. /* Dialog Window Procedure                                                 */
  2061. /*                                                                         */
  2062. /* This procedure is associated with the dialog box that is included in    */
  2063. /* the function name of the procedure. It provides the service routines    */
  2064. /* for the events (messages) that occur because the end user operates      */
  2065. /* one of the dialog box's buttons, entry fields, or controls.             */
  2066. /*                                                                         */
  2067. /* The SWITCH statement in the function distributes the dialog box         */
  2068. /* messages to the respective service routines, which are set apart by     */
  2069. /* the CASE clauses. Like any other PM window, the Dialog Window           */
  2070. /* procedures must provide an appropriate service routine for their end    */
  2071. /* user initiated messages as well as for the general PM messages (like    */
  2072. /* the WM_CLOSE message). If a message is sent to this procedure for       */
  2073. /* which there is no programmed CASE condition (no service routine),       */
  2074. /* the message is defaulted to the WinDefDlgProc function, where it is     */
  2075. /* disposed of by PM.                                                      */
  2076. /*                                                                         */
  2077. /***************************************************************************/
  2078.  
  2079. MRESULT EXPENTRY NO_CONMsgProc(hWndDlg, message, mp1, mp2)
  2080. HWND hWndDlg;
  2081. USHORT message;
  2082. MPARAM mp1;
  2083. MPARAM mp2;
  2084. { 
  2085.  static SHORT sfValidate = TRUE;
  2086.  INT    i;
  2087.  static HWND  hWndParent;
  2088.           
  2089.  switch(message)
  2090.    {
  2091.     case WM_INITDLG:
  2092.          hWndParent = (HWND)mp2;
  2093.          cwCenter(hWndDlg, (HWND)hWndFrame);
  2094.          break; /* End of WM_INITDLG */
  2095.    
  2096.     case WM_CONTROL:
  2097.          switch(SHORT1FROMMP(mp1))
  2098.            {
  2099.            }
  2100.          break; /* End of WM_CONTROL */
  2101.    
  2102.     case WM_COMMAND:
  2103.          switch(SHORT1FROMMP(mp1))
  2104.            {
  2105.             case DID_OK: /* Button text: "Ok"                              */
  2106.                  WinDismissDlg(hWndDlg, TRUE);
  2107.                  break;
  2108.  
  2109.             case 259: /* Button text: "Help"                               */
  2110.                  break;
  2111.  
  2112.            }
  2113.          break; /* End of WM_COMMAND */
  2114.                                
  2115.     case WM_CLOSE:
  2116.          WinDismissDlg(hWndDlg, FALSE);
  2117.          break; /* End of WM_CLOSE */
  2118.            
  2119.     case WM_FAILEDVALIDATE:
  2120.          WinAlarm(HWND_DESKTOP, WA_ERROR);
  2121.          sfValidate = FALSE;
  2122.          WinSetFocus(HWND_DESKTOP, WinWindowFromID(hWndDlg, SHORT1FROMMP(mp1)));
  2123.          sfValidate = TRUE;
  2124.          return((MRESULT)TRUE);
  2125.          break; /* End of WM_FAILEDVALIDATE */
  2126.  
  2127.     default:
  2128.          return(WinDefDlgProc(hWndDlg, message, mp1, mp2));
  2129.          break;
  2130.    }
  2131.  return FALSE;
  2132. } /* End of NO_CONMsgProc */
  2133.  
  2134.  
  2135. /***************************************************************************/
  2136. /*                                                                         */
  2137. /* Dialog Window Procedure                                                 */
  2138. /*                                                                         */
  2139. /* This procedure is associated with the dialog box that is included in    */
  2140. /* the function name of the procedure. It provides the service routines    */
  2141. /* for the events (messages) that occur because the end user operates      */
  2142. /* one of the dialog box's buttons, entry fields, or controls.             */
  2143. /*                                                                         */
  2144. /* The SWITCH statement in the function distributes the dialog box         */
  2145. /* messages to the respective service routines, which are set apart by     */
  2146. /* the CASE clauses. Like any other PM window, the Dialog Window           */
  2147. /* procedures must provide an appropriate service routine for their end    */
  2148. /* user initiated messages as well as for the general PM messages (like    */
  2149. /* the WM_CLOSE message). If a message is sent to this procedure for       */
  2150. /* which there is no programmed CASE condition (no service routine),       */
  2151. /* the message is defaulted to the WinDefDlgProc function, where it is     */
  2152. /* disposed of by PM.                                                      */
  2153. /*                                                                         */
  2154. /***************************************************************************/
  2155.  
  2156. MRESULT EXPENTRY UN_CATMsgProc(hWndDlg, message, mp1, mp2)
  2157. HWND hWndDlg;
  2158. USHORT message;
  2159. MPARAM mp1;
  2160. MPARAM mp2;
  2161. { 
  2162.  static SHORT sfValidate = TRUE;
  2163.  INT    i;
  2164.  static HWND  hWndParent;
  2165.  static char  sz_un_dbase[9];
  2166.  char         *pspace;
  2167.  static short us_cat_index;   
  2168.           
  2169.  switch(message)
  2170.    {
  2171.     case WM_INITDLG:
  2172.          hWndParent = (HWND)mp2;
  2173.          cwCenter(hWndDlg, (HWND)hWndParent);
  2174.  
  2175.          SQLGDOPS('0', &us_hand_dir, &us_count_dir, &sqlca);
  2176.  
  2177.          for(i=0;i<us_count_dir;i++)
  2178.             {
  2179.             SQLGDGNE(us_hand_dir, &st_info, &sqlca);
  2180.             strncpy(sz_un_alias[i], st_info->alias, 8);
  2181.             sz_un_alias[i][8] = '\0';
  2182.  
  2183.             WinSendDlgItemMsg(hWndDlg,
  2184.                                   256,
  2185.                         LM_INSERTITEM,
  2186.               MPFROM2SHORT(LIT_END,0),
  2187.               MPFROMP(sz_un_alias[i]));
  2188.             }
  2189.  
  2190.          SQLGDCLS(us_hand_dir, &sqlca);
  2191.  
  2192.          break; /* End of WM_INITDLG */
  2193.    
  2194.     case WM_CONTROL:
  2195.          switch(SHORT1FROMMP(mp1))
  2196.            {
  2197.             case 256: /* List box                                          */
  2198.                  {
  2199.                  us_cat_index = (USHORT)WinSendDlgItemMsg(hWndDlg,
  2200.                                                               256,
  2201.                                                 LM_QUERYSELECTION,
  2202.                                                       (short)NULL,
  2203.                                                      (short)NULL);
  2204.                        
  2205.                   if (us_cat_index == LIT_NONE)
  2206.                     {
  2207.                     strcpy(sz_dbase,"--New--");
  2208.                     }
  2209.                  else
  2210.                     {
  2211.                     strcpy(sz_un_dbase, sz_un_alias[us_cat_index]);
  2212.  
  2213.                     if ((pspace = strchr(sz_un_dbase, ' ')) != NULL)
  2214.                        {
  2215.                        *pspace = '\0';
  2216.                        }
  2217.  
  2218.                     sz_un_dbase[8] = '\0';
  2219.                     }
  2220.                  }
  2221.                  break;
  2222.  
  2223.            }
  2224.          break; /* End of WM_CONTROL */
  2225.    
  2226.     case WM_COMMAND:
  2227.          switch(SHORT1FROMMP(mp1))
  2228.            {
  2229.             case DID_OK: /* Button text: "Ok"                              */
  2230.  
  2231.                  SQLGUNCD(strlen(sz_un_dbase), &sqlca, sz_un_dbase);
  2232.  
  2233.                  if (sqlca.sqlcode != 0)
  2234.                     {
  2235.                     DosBeep(500,500);
  2236.                     }
  2237.  
  2238.                  WinDismissDlg(hWndDlg, TRUE);
  2239.                  break;
  2240.  
  2241.             case DID_CANCEL: /* Button text: "Cancel"                      */
  2242.                  /* Ignore data values entered into the dialog controls    */
  2243.                  /* and dismiss the dialog window                          */
  2244.                  WinDismissDlg(hWndDlg, FALSE);
  2245.                  break;
  2246.  
  2247.             case 259: /* Button text: "Help"                               */
  2248.                  break;
  2249.  
  2250.            }
  2251.          break; /* End of WM_COMMAND */
  2252.                                
  2253.     case WM_CLOSE:
  2254.          WinPostMsg(hWndDlg, WM_COMMAND, MPFROMSHORT(DID_CANCEL), 0L);
  2255.          break; /* End of WM_CLOSE */
  2256.            
  2257.     case WM_FAILEDVALIDATE:
  2258.          WinAlarm(HWND_DESKTOP, WA_ERROR);
  2259.          sfValidate = FALSE;
  2260.          WinSetFocus(HWND_DESKTOP, WinWindowFromID(hWndDlg, SHORT1FROMMP(mp1)));
  2261.          sfValidate = TRUE;
  2262.          return((MRESULT)TRUE);
  2263.          break; /* End of WM_FAILEDVALIDATE */
  2264.  
  2265.     default:
  2266.          return(WinDefDlgProc(hWndDlg, message, mp1, mp2));
  2267.          break;
  2268.    }
  2269.  return FALSE;
  2270. } /* End of UN_CATMsgProc */
  2271.  
  2272.  
  2273. /***************************************************************************/
  2274. /*                                                                         */
  2275. /* Dialog Window Procedure                                                 */
  2276. /*                                                                         */
  2277. /* This procedure is associated with the dialog box that is included in    */
  2278. /* the function name of the procedure. It provides the service routines    */
  2279. /* for the events (messages) that occur because the end user operates      */
  2280. /* one of the dialog box's buttons, entry fields, or controls.             */
  2281. /*                                                                         */
  2282. /* The SWITCH statement in the function distributes the dialog box         */
  2283. /* messages to the respective service routines, which are set apart by     */
  2284. /* the CASE clauses. Like any other PM window, the Dialog Window           */
  2285. /* procedures must provide an appropriate service routine for their end    */
  2286. /* user initiated messages as well as for the general PM messages (like    */
  2287. /* the WM_CLOSE message). If a message is sent to this procedure for       */
  2288. /* which there is no programmed CASE condition (no service routine),       */
  2289. /* the message is defaulted to the WinDefDlgProc function, where it is     */
  2290. /* disposed of by PM.                                                      */
  2291. /*                                                                         */
  2292. /***************************************************************************/
  2293.  
  2294. MRESULT EXPENTRY UN_NODEMsgProc(hWndDlg, message, mp1, mp2)
  2295. HWND hWndDlg;
  2296. USHORT message;
  2297. MPARAM mp1;
  2298. MPARAM mp2;
  2299. { 
  2300.  static SHORT sfValidate = TRUE;
  2301.  INT          i, us_un_node_index;
  2302.  static HWND  hWndParent;
  2303.  static char  *pspace;
  2304.  static char  sz_un_node[9];
  2305.           
  2306.  switch(message)
  2307.    {
  2308.     case WM_INITDLG:
  2309.          hWndParent = (HWND)mp2;
  2310.          cwCenter(hWndDlg, (HWND)hWndParent);
  2311.  
  2312.          SQLGNOPS(&us_hand_node, &us_count_node, &sqlca);
  2313.  
  2314.          for(i=0;i<us_count_node;i++)
  2315.             {
  2316.             SQLGNGNE(us_hand_node, &st_node, &sqlca);
  2317.             strncpy(sz_un_nodename[i], st_node->nodename, 8);
  2318.             sz_un_nodename[i][8] = '\0';
  2319.  
  2320.             WinSendDlgItemMsg(hWndDlg,
  2321.                                   256,
  2322.                         LM_INSERTITEM,
  2323.               MPFROM2SHORT(LIT_END,0),
  2324.               MPFROMP(sz_un_nodename[i]));
  2325.             }
  2326.  
  2327.          SQLGNCLS(us_hand_node, &sqlca);
  2328.  
  2329.          break; /* End of WM_INITDLG */
  2330.    
  2331.     case WM_CONTROL:
  2332.          switch(SHORT1FROMMP(mp1))
  2333.            {
  2334.             case 256: /* List box                                          */
  2335.                  {
  2336.                  us_un_node_index = (USHORT)WinSendDlgItemMsg(hWndDlg,
  2337.                                                                   256,
  2338.                                                     LM_QUERYSELECTION,
  2339.                                                           (short)NULL,
  2340.                                                          (short)NULL);
  2341.                        
  2342.                   if (us_un_node_index == LIT_NONE)
  2343.                     {
  2344.                     strcpy(sz_rds_name,"--New--");
  2345.                     }
  2346.                  else
  2347.                     {
  2348.                     strcpy(sz_un_node, sz_un_nodename[us_un_node_index]);
  2349.  
  2350.                     if ((pspace = strchr(sz_un_node, ' ')) != NULL)
  2351.                        {
  2352.                        *pspace = '\0';
  2353.                        }
  2354.  
  2355.                     sz_un_node[8] = '\0';
  2356.                     }
  2357.                  }
  2358.                  break;
  2359.  
  2360.            }
  2361.          break; /* End of WM_CONTROL */
  2362.    
  2363.     case WM_COMMAND:
  2364.          switch(SHORT1FROMMP(mp1))
  2365.            {
  2366.             case DID_OK: /* Button text: "Ok"                              */
  2367.                  
  2368.                  SQLGUNCN(strlen(sz_un_node), &sqlca, sz_un_node);
  2369.  
  2370.                  if (sqlca.sqlcode != 0)
  2371.                     {
  2372.                     DosBeep(400,500);
  2373.                     } 
  2374.  
  2375.                  WinDismissDlg(hWndDlg, TRUE);
  2376.                  break;
  2377.  
  2378.             case DID_CANCEL: /* Button text: "Cancel"                      */
  2379.                  /* Ignore data values entered into the dialog controls    */
  2380.                  /* and dismiss the dialog window                          */
  2381.                  WinDismissDlg(hWndDlg, FALSE);
  2382.                  break;
  2383.  
  2384.             case 259: /* Button text: "Help"                               */
  2385.                  break;
  2386.  
  2387.            }
  2388.          break; /* End of WM_COMMAND */
  2389.                                
  2390.     case WM_CLOSE:
  2391.          WinPostMsg(hWndDlg, WM_COMMAND, MPFROMSHORT(DID_CANCEL), 0L);
  2392.          break; /* End of WM_CLOSE */
  2393.            
  2394.     case WM_FAILEDVALIDATE:
  2395.          WinAlarm(HWND_DESKTOP, WA_ERROR);
  2396.          sfValidate = FALSE;
  2397.          WinSetFocus(HWND_DESKTOP, WinWindowFromID(hWndDlg, SHORT1FROMMP(mp1)));
  2398.          sfValidate = TRUE;
  2399.          return((MRESULT)TRUE);
  2400.          break; /* End of WM_FAILEDVALIDATE */
  2401.  
  2402.     default:
  2403.          return(WinDefDlgProc(hWndDlg, message, mp1, mp2));
  2404.          break;
  2405.    }
  2406.  return FALSE;
  2407. } /* End of UN_NODEMsgProc */
  2408.  
  2409.  
  2410.  
  2411.  
  2412. /***************************************************************************/
  2413. /*                                                                         */
  2414. /* cwRegisterClass Function                                                */
  2415. /*                                                                         */
  2416. /* The following function registers all the classes of all the windows     */
  2417. /* associated with this application. The function returns TRUE if it is    */
  2418. /* successful, otherwise it returns FALSE.                                 */
  2419. /*                                                                         */
  2420. /***************************************************************************/
  2421.  
  2422. INT cwRegisterClass()
  2423. {
  2424.  INT rc;
  2425.  
  2426.  strcpy(szAppName, "LUDOSPY");
  2427.  rc = WinRegisterClass(hAB,             /* Anchor block handle             */
  2428.                       (PCH)szAppName,   /* Name of class being registered  */
  2429.                       (PFNWP)WndProc,   /* Window procedure for class      */
  2430.                       CS_SIZEREDRAW ,
  2431.                       1*sizeof(char FAR *));
  2432.  if (rc == FALSE)
  2433.    return(FALSE);
  2434.  
  2435.  return(TRUE);
  2436. } /* End of cwRegisterClass */
  2437.  
  2438.  
  2439.  
  2440. /***************************************************************************/
  2441. /*                                                                         */
  2442. /* cwCreateWindow Function                                                 */
  2443. /*                                                                         */
  2444. /* The following function is used to create a window (the main window,     */
  2445. /* a child window, an icon window, etc.) and set it's initial size and     */
  2446. /* position. It returns the handle to the frame window.                    */
  2447. /*                                                                         */
  2448. /***************************************************************************/
  2449.  
  2450. HWND cwCreateWindow(
  2451.    HWND   hWndParent,  /* Handle to the parent of the window to be created */
  2452.    ULONG  ctldata,     /* Frame control flags for the window               */
  2453.    PCH    appname,     /* Class name of the window                         */
  2454.    PCH    title,       /* Title of the window                              */
  2455.    USHORT ResID,       /* Resource id value                                */
  2456.    INT    x,           /* Initial horizontal and vertical location         */
  2457.    INT    y,
  2458.    INT    cx,          /* Initial width and height of the window           */
  2459.    INT    cy, 
  2460.    PHWND  hWndClient,  /* Handle to the client area of the window          */
  2461.    ULONG  lfStyle,     /* Frame window style                               */
  2462.    USHORT uSizeStyle)  /* User defined size and location flags             */
  2463. {
  2464.    USHORT rc;            /* accepts return codes from function calls       */
  2465.    HWND   hWndFrame;     /* local handle to created window frame           */
  2466.    USHORT SizeStyle;     /* local window positioning options               */
  2467.    CHAR   MsgBuffer[80]; /* buffer for error messages                      */
  2468.    HPS    hPS;           /* handle to a presentation space                 */
  2469.    int    xmod, ymod;    /* modifiers for sizing                           */
  2470.    #define DLGXMOD  4    /* Dialog units X modulo */
  2471.    #define DLGYMOD  8    /* Dialog units Y modulo */
  2472.    FONTMETRICS fm;       /* structure for determing modifiers              */
  2473.    /* Create the frame window                                              */
  2474.    hWndFrame = WinCreateStdWindow(hWndParent,  /* parent of window         */
  2475.                                   lfStyle,     /* frame window style       */
  2476.                                   &ctldata,    /* frame flags              */
  2477.                                   appname,     /* class name               */
  2478.                                   title,       /* window title             */
  2479.                                   0L,          /* client window style      */
  2480.                                   0,           /* module for resources     */
  2481.                                   ResID,       /* resource id              */
  2482.                                   (HWND FAR *)hWndClient); /* client handle*/
  2483.  
  2484.    /* if hWndFrame is NULL, an error occured when opening the window,      */
  2485.    /*     notify the user and exit this function                           */
  2486.    if(hWndFrame == 0)
  2487.      {
  2488.       WinLoadString(hAB, 0, IDS_ERR_WINDOW_CREATE, 80, MsgBuffer);
  2489.       WinMessageBox(HWND_DESKTOP, hWndParent, MsgBuffer,
  2490.                     0, 0, MB_OK|MB_ICONEXCLAMATION);
  2491.       return((HWND)0);
  2492.      }
  2493.  
  2494.    /* set up size options                                                  */
  2495.    SizeStyle = SWP_ACTIVATE | SWP_ZORDER | uSizeStyle;
  2496.  
  2497.    /* if the height, width, intial x or initial y values are non-zero,     */
  2498.    /*     then we will need to set up the modifiers for size and location  */
  2499.    if((cx > 0) || (cy > 0) ||
  2500.       (x > 0)  || (y > 0))
  2501.      {
  2502.       hPS = WinGetPS(HWND_DESKTOP);
  2503.       GpiQueryFontMetrics(hPS, (LONG)sizeof(FONTMETRICS), &fm);
  2504.       xmod = (INT)fm.lAveCharWidth;
  2505.       ymod = (INT)fm.lMaxBaselineExt;
  2506.       WinReleasePS(hPS);
  2507.      }
  2508.    /* if either the width or the height are non-zero, then the size of the */
  2509.    /*     created window will be changed, set SizeStyle accordingly        */
  2510.    if((cx > 0) || (cy > 0))
  2511.      SizeStyle |= SWP_SIZE;
  2512.    /* set the size and position of the window and activate it              */
  2513.    rc = WinSetWindowPos(hWndFrame, HWND_TOP, 0, 0,
  2514.                         (USHORT)(cx * xmod)/DLGXMOD,
  2515.                         (USHORT)(cy * ymod)/DLGYMOD, SizeStyle);
  2516.  
  2517.    /* if the either the intial x or y position of the window is non-zero,  */
  2518.    /*    set the window to its new position                                */
  2519.    if((x > 0) || (y > 0))
  2520.      rc = WinSetWindowPos(hWndFrame, HWND_TOP,
  2521.                           (USHORT)(x * xmod)/DLGXMOD,
  2522.                           (USHORT)(y * ymod)/DLGYMOD, 0, 0, SWP_MOVE);
  2523.    
  2524.    /* if rc is not set to TRUE then WinSetWindowPos failed, notify the user*/
  2525.    /*     and exit this function                                           */
  2526.    if(!rc)
  2527.      {
  2528.       WinLoadString(hAB, 0, IDS_ERR_WINDOW_POS, 80, MsgBuffer);
  2529.       WinMessageBox(HWND_DESKTOP, hWndParent, MsgBuffer,
  2530.                     0, 0, MB_OK|MB_ICONEXCLAMATION);
  2531.       return((HWND)0);
  2532.      }
  2533.  
  2534.    /* return the handle to the frame window                                */
  2535.    return(hWndFrame);
  2536. }  /* End of cwCreateWindow */
  2537.  
  2538.  
  2539. /***************************************************************************/
  2540. /*  cwCenter Function                                                      */
  2541. /*                                                                         */
  2542. /*  Centers a dialog box on the client area of the caller                  */
  2543. /*                                                                         */
  2544. /***************************************************************************/
  2545.  
  2546. INT cwCenter(hWnd, hWndParent)                                              
  2547. HWND hWnd;         /* handle of the window to be centered                  */
  2548. HWND hWndParent;   /* handle of the window to center on                    */
  2549. {
  2550.   ULONG  SrcX, SrcY;                /* Center of parent                    */
  2551.   INT    ix, iy;                    /* Destination points                  */
  2552.   SWP    DlgSwp, ParentSwp;         /* Set window position structures      */
  2553.   ULONG  ScreenWidth, ScreenHeight; /* Dimensions of the DESKTOP           */
  2554.   POINTL pt;                        /* Point                               */
  2555.  
  2556.   /* Determine the width and height of the DESKTOP so the dialog box       */
  2557.   /* will not be positioned to a point off of the screen.                  */
  2558.   ScreenWidth  = (ULONG)WinQuerySysValue(HWND_DESKTOP, SV_CXSCREEN);
  2559.   ScreenHeight = (ULONG)WinQuerySysValue(HWND_DESKTOP, SV_CYSCREEN);
  2560.  
  2561.   /* Query width and depth of dialog box                                   */
  2562.   WinQueryWindowPos(hWnd, (PSWP)&DlgSwp);
  2563.  
  2564.   /* Query width and depth of caller                                       */
  2565.   WinQueryWindowPos(hWndParent, (PSWP)&ParentSwp);
  2566.  
  2567.   /* Map the point parent points to the Desktop                            */
  2568.   pt.x = ParentSwp.x;
  2569.   pt.y = ParentSwp.y;
  2570.  
  2571.   /* Convert the point from having our window as the origin to having      */
  2572.   /* the DESKTOP as the origin                                             */
  2573.   WinMapWindowPoints(hWndParent, HWND_DESKTOP, &pt, 1);
  2574.  
  2575.   SrcX = pt.x + (ParentSwp.cx / 2);
  2576.   SrcY = pt.y + (ParentSwp.cy / 2);
  2577.  
  2578.   /* Determine the point to move the dialog box to                         */
  2579.   ix = (INT)(SrcX - (DlgSwp.cx / 2));
  2580.   iy = (INT)(SrcY - (DlgSwp.cy / 2));
  2581.  
  2582.   /* if either point is less than zero, then set that point to zero        */
  2583.   /* so the dialog box will not be positoned off of the window             */
  2584.   ix = (ix < 0) ? 0 : ix;
  2585.   iy = (iy < 0) ? 0 : iy;
  2586.  
  2587.   /* if either point plus the height or width of the dialog box is         */
  2588.   /* greater than the height or width of the screen adjust point           */
  2589.   if(((ULONG)ix + DlgSwp.cx) > ScreenWidth)
  2590.     ix = (INT)(ScreenWidth - DlgSwp.cx);
  2591.   if(((ULONG)iy + DlgSwp.cy) > ScreenHeight)
  2592.     iy = (INT)(ScreenHeight - DlgSwp.cy);
  2593.  
  2594.   /* move the dialog box                                                   */
  2595.   return(WinSetWindowPos(hWnd, HWND_TOP, ix, iy, 0, 0, SWP_MOVE));
  2596. }
  2597.  
  2598.  
  2599. /* This function initializes the states of all dialog box radio buttons    */
  2600. /* and check boxes that have had their initial status set to true          */
  2601. INT cwSetInitDlgStatus(hWnd)
  2602. HWND hWnd;
  2603. {
  2604.   CATStruct FAR *Cat;
  2605.  
  2606.   OFFSETOF(Cat) = 0;
  2607.   DosAllocSeg(sizeof(CATStruct), (PSEL)&SELECTOROF(Cat), 0);
  2608.   lmemset(Cat, 0x00, sizeof(CATStruct));
  2609.   WinSetWindowULong(hWnd, OFFSET_CAT, (ULONG)Cat);
  2610.   Cat->YourWindowsTitleGoesHere = 257;
  2611.  
  2612. }
  2613.  
  2614. INT cwFreeDlgMemory(hWnd)
  2615. HWND hWnd;
  2616. {
  2617.   CATStruct FAR *Cat;
  2618.  
  2619.   Cat = (CATStruct FAR *)WinQueryWindowULong(hWnd, OFFSET_CAT);
  2620.   DosFreeSeg(SELECTOROF(Cat));
  2621. }
  2622.  
  2623. void lmemset(memptr, value, size)
  2624. void FAR *memptr;
  2625. char     value;
  2626. int      size;
  2627. {
  2628.    char FAR *chrptr = memptr;
  2629.  
  2630.    while (size--)
  2631.       *chrptr++ = value;
  2632. }
  2633.  
  2634. /* LONGSTRCPY - is a functional equivalent to the C library routine        */
  2635. /*              strcpy, with the exception that it takes far pointers to   */
  2636. /*              to character strings as it's parameters.                   */
  2637. PSZ longstrcpy(target, source)
  2638. PSZ target;
  2639. PSZ source;
  2640. {
  2641.  PSZ z = target;
  2642.  while(*target++ = *source++);
  2643.  return(z);
  2644. }
  2645.  
  2646.  
  2647. int cwCheckDlgItem(hWndDlg, id, state)
  2648. HWND hWndDlg;
  2649. INT  id;
  2650. INT  state;
  2651. {
  2652.  return((INT)WinSendDlgItemMsg(hWndDlg, id,
  2653.                                BM_SETCHECK, MPFROMSHORT(state), 0L));
  2654. }
  2655.  
  2656. /*............................................................
  2657. :                                                            :
  2658. :  ..........................................................:...........
  2659. :  :                                                                    :
  2660. :..:   db_crash()                                                       :
  2661.    :                                                                    :
  2662.    :...................................................................*/
  2663.  
  2664.   void db_crash(void)
  2665.      {
  2666.      int x;
  2667.  
  2668.      ltoa(sqlca.sqlcode, sz_code, 10);
  2669.  
  2670.      if (!bit_flag.time)
  2671.         {
  2672.         while(!kbhit())
  2673.            {
  2674.            DosBeep(500,500);
  2675.            DosSleep(DELAY);
  2676.            }
  2677.         }
  2678.  
  2679.      DosBeep(500,500);
  2680.      DosSleep(DELAY);
  2681.  
  2682.      } /* end db_crash */
  2683.  
  2684. /*............................................................
  2685. :                                                            :
  2686. :  ..........................................................:...........
  2687. :  :                                                                    :
  2688. :..:   sort_users()                                                     :
  2689.    :                                                                    :
  2690.    :...................................................................*/
  2691.  
  2692.   void sort_users(void)
  2693.      {
  2694.      register int a;
  2695.      register int b;
  2696.  
  2697.      for(a=1;a<basestat.connects;a++)
  2698.         {
  2699.         basestat.ustat[100] = basestat.ustat[a];
  2700.         b = a - 1;
  2701.         while((b >= 0) && (strncmp(basestat.ustat[100].authid,
  2702.               basestat.ustat[b].authid, 16)) < 0 )
  2703.            {
  2704.            basestat.ustat[b+1] = basestat.ustat[b];
  2705.            b--;
  2706.            }
  2707.  
  2708.         basestat.ustat[b+1] = basestat.ustat[100];
  2709.         }
  2710.  
  2711.      } /* end sort_users() */
  2712.  
  2713. /*............................................................
  2714. :                                                            :
  2715. :  ..........................................................:...........
  2716. :  :                                                                    :
  2717. :..:   LimitLBox(HWND, USHORT)                                          :
  2718.    :                                                                    :
  2719.    :...................................................................*/
  2720.  
  2721. static  FONTMETRICS g_font_metrics;
  2722.  
  2723. static  SHORT       sFontInitialized = 0;
  2724. static  CHAR        sz_temp_string[1024];
  2725.  
  2726. MRESULT EXPENTRY LimitLBox( HWND hWndDlg, USHORT sLength ) 
  2727. {
  2728.     HPS         hps;
  2729.  
  2730.     if ( !sFontInitialized ) 
  2731.         {
  2732.         sFontInitialized = 1;
  2733.         hps = WinBeginPaint( hWndDlg, NULL, NULL );
  2734.         GpiQueryFontMetrics( hps, (LONG)sizeof(FONTMETRICS), &g_font_metrics );
  2735.         WinEndPaint( hps );
  2736.         }
  2737.     return( MPFROM2SHORT( g_font_metrics.lMaxBaselineExt, sLength ) );
  2738. }
  2739.  
  2740. /*............................................................
  2741. :                                                            :
  2742. :  ..........................................................:...........
  2743. :  :                                                                    :
  2744. :..:   AlignLBox(HWND, USHORT, USHORT, MPARAM)                          :
  2745.    :                                                                    :
  2746.    :...................................................................*/
  2747.  
  2748. MRESULT EXPENTRY AlignLBox( HWND hWndDlg, USHORT sResource, 
  2749.                             USHORT *cols, MPARAM mparam2 )
  2750. {
  2751.     POWNERITEM     ptr_owner_item;
  2752.     RECTL          rectl;
  2753.     POINTL         ptl;
  2754.     PCHAR          psz_token;
  2755.  
  2756.     memset( sz_temp_string, '\0', sizeof(sz_temp_string) );
  2757.  
  2758.     ptr_owner_item = (POWNERITEM)PVOIDFROMMP( mparam2 );
  2759.  
  2760.     WinSendDlgItemMsg( hWndDlg, sResource, LM_QUERYITEMTEXT, 
  2761.         MPFROM2SHORT( ptr_owner_item->idItem, sizeof(sz_temp_string) ),
  2762.         MPFROMP( sz_temp_string ));
  2763.  
  2764.     rectl.xLeft     = ptr_owner_item->rclItem.xLeft;
  2765.     rectl.yBottom   = ptr_owner_item->rclItem.yBottom;
  2766.     rectl.xRight    = ptr_owner_item->rclItem.xRight;
  2767.     rectl.yTop      = ptr_owner_item->rclItem.yTop;
  2768.  
  2769.     ptl.x = rectl.xLeft;
  2770.     ptl.y = rectl.yBottom + g_font_metrics.lMaxDescender;
  2771.  
  2772.     WinFillRect( ptr_owner_item->hps, &rectl, SYSCLR_WINDOW );
  2773.  
  2774.     if ( ptr_owner_item->fsState == FALSE && ptr_owner_item->fsStateOld == TRUE )
  2775.         GpiSetBackColor( ptr_owner_item->hps, CLR_WHITE );
  2776.  
  2777.     psz_token = strtok( sz_temp_string, "~" );
  2778.     while ( psz_token != NULL )
  2779.         {
  2780.         ptl.x += *cols++;
  2781.         GpiCharStringAt( ptr_owner_item->hps, &ptl,
  2782.             (LONG)strlen( psz_token ), psz_token );
  2783.         psz_token = strtok( NULL, "~" );
  2784.         }
  2785.  
  2786.     if ( ptr_owner_item->fsState == FALSE && ptr_owner_item->fsStateOld == TRUE )
  2787.         ptr_owner_item->fsStateOld = FALSE;
  2788.  
  2789.     return (MRESULT) 1;
  2790. }
  2791.  
  2792. /*............................................................
  2793. :                                                            :
  2794. :  ..........................................................:...........
  2795. :  :                                                                    :
  2796. :..:   get_time()                                                       :
  2797.    :                                                                    :
  2798.    :...................................................................*/
  2799.  
  2800.   void get_time()
  2801.      {
  2802.      time(&bintime);
  2803.  
  2804.      curtime = localtime(&bintime);     
  2805.  
  2806.      } /* end get_time() */
  2807.  
  2808. /*.............................................................
  2809. :                                                             :
  2810. :   main                                                      :
  2811. :      .......................................................:......
  2812. :      :                                                            :
  2813. :      :   ctrl                                                     :
  2814. :......:    ........................................................:......
  2815.        :    :                                                             :
  2816.        :    :                                                             :
  2817.        :....:   write_user_stats(void)                                    :
  2818.             :                                                             :
  2819.             :                                                             :
  2820.             :............................................................*/
  2821.  
  2822.   void write_user_stats(void)
  2823.      {
  2824.      char           sz_trans[17];
  2825.      char           sz_sql_con[17];
  2826.      char           sz_sql_trans[17];
  2827.      char           sz_trans_time[17];
  2828.  
  2829.      unsigned short us_buff_size;
  2830.      unsigned short i;
  2831.      
  2832.      for(i=0;i<basestat.connects;i++)
  2833.         {
  2834.         strcpy(sz_user_buff, "User: ");
  2835.         strncat(sz_user_buff, basestat.ustat[i].authid, 8);
  2836.  
  2837.         strcat(sz_user_buff, " Node: ");
  2838.         strncat(sz_user_buff, basestat.ustat[i].node, 8);
  2839. /*
  2840.         strcat(sz_user_buff, " Auth. Level: ");
  2841.  
  2842.         if (basestat.ustat[i].authority_lvl & SQL_SYSADM)
  2843.            {
  2844.            strcat(sz_user_buff, "SYS ADM");
  2845.            }
  2846.  
  2847.         if (basestat.ustat[i].authority_lvl & SQL_DBADM)
  2848.            {
  2849.            strcat(sz_user_buff, "DB  ADM");
  2850.            }
  2851.  
  2852.         if (basestat.ustat[i].authority_lvl & SQL_CONNECT)
  2853.            {
  2854.            strcat(sz_user_buff, "CONNECT");
  2855.            }                     
  2856. */
  2857.         strcat(sz_user_buff, " Connect Time: "); 
  2858.         con_time = bintime - basestat.ustat[i].connect_time;
  2859.         out_time = localtime(&con_time);
  2860.         strncat(sz_user_buff, asctime(out_time), 24);
  2861.  
  2862.         strcat(sz_user_buff, " Trans/connect: ");
  2863.         ltoa(basestat.ustat[i].con_trans, sz_trans, 10);
  2864.         strncat(sz_user_buff, sz_trans, 16);
  2865.  
  2866.         strcat(sz_user_buff, " SQL/connect: ");
  2867.         ltoa(basestat.ustat[i].con_reqs, sz_sql_con, 10);
  2868.         strncat(sz_user_buff, sz_sql_con, 16);
  2869.  
  2870.         strcat(sz_user_buff, " SQL/trans: ");
  2871.         ltoa(basestat.ustat[i].cur_reqs, sz_sql_trans, 10);
  2872.         strncat(sz_user_buff, sz_sql_trans, 16);
  2873.  
  2874.         strcat(sz_user_buff, " Sec. curr/trans: ");
  2875.         ltoa(basestat.ustat[i].trans_time, sz_trans_time, 10);
  2876.         strncat(sz_user_buff, sz_sql_trans, 16);
  2877.  
  2878.         strcat(sz_user_buff, " T.S.: ");
  2879.         if (basestat.ustat[i].trans_state == 'S')
  2880.            {
  2881.            strcat(sz_user_buff, "S");
  2882.            }
  2883.  
  2884.         if (basestat.ustat[i].trans_state == 'R')
  2885.            {
  2886.            strcat(sz_user_buff, "R");
  2887.            }
  2888.  
  2889.         if (basestat.ustat[i].trans_state == 'C')
  2890.            {
  2891.            strcat(sz_user_buff, "C");
  2892.            }
  2893.  
  2894.         strcat(sz_user_buff, " L.S.: ");
  2895.         if (basestat.ustat[i].lock_state == 'W')
  2896.            {
  2897.            strcat(sz_user_buff, "W");
  2898.            }
  2899.         else
  2900.            {
  2901.            strcat(sz_user_buff, "N");
  2902.            }
  2903.  
  2904.         fprintf(spyfile, "%s\n", sz_user_buff);
  2905.  
  2906.         } /* end of while */
  2907.  
  2908.      fprintf(spyfile, "\n");
  2909. /*     bit_flag.exit = TRUE;    */
  2910.  
  2911.      } /* end write_user_stats() */
  2912.  
  2913. /*.............................................................
  2914. :                                                             :
  2915. :   main                                                      :
  2916. :      .......................................................:......
  2917. :      :                                                            :
  2918. :      :   ctrl                                                     :
  2919. :......:    ........................................................:......
  2920.        :    :                                                             :
  2921.        :    :                                                             :
  2922.        :....:   write_db_stats()                                          :
  2923.             :                                                             :
  2924.             :                                                             :
  2925.             :............................................................*/
  2926.  
  2927.   void write_db_stats()
  2928.      {
  2929.      strncpy(sz_buff, basestat.release_lvl, 4);
  2930.      strcat(sz_buff, " ");
  2931.      strncat(sz_buff, basestat.corr_serv_lvl, 8);
  2932.  
  2933.      fprintf(spyfile, "%s\n", sz_buff);
  2934.  
  2935.      strcpy(sz_buff, "Database Name: ");
  2936.      strncat(sz_buff, basestat.db_name, 16);
  2937.  
  2938.      fprintf(spyfile, "%s\n", sz_buff);
  2939.  
  2940.      strcpy(sz_buff, "Database alias: ");
  2941.      strncat(sz_buff, basestat.db_alias, 16);
  2942.  
  2943.      fprintf(spyfile, "%s\n", sz_buff);
  2944.  
  2945.      strcpy(sz_buff, "Drive: ");
  2946.      strncat(sz_buff, basestat.drive, 2);
  2947.  
  2948.      fprintf(spyfile, "%s\n", sz_buff);
  2949.  
  2950.      strcpy(sz_buff, "Location: ");
  2951.      if (basestat.location == 'L')
  2952.         {
  2953.         strcat(sz_buff, "Local");
  2954.         }
  2955.      else
  2956.         {
  2957.         strcat(sz_buff, "Remote");
  2958.         }
  2959.  
  2960.      fprintf(spyfile, "%s\n", sz_buff);
  2961.  
  2962.      strcpy(sz_buff, "Node: ");
  2963.      strncat(sz_buff, basestat.node, 8);
  2964.  
  2965.      fprintf(spyfile, "%s\n", sz_buff);
  2966.  
  2967.      strcpy(sz_buff, "Current connects: ");
  2968.      itoa(basestat.connects, sz_conns, 10);
  2969.      strcat(sz_buff, sz_conns);
  2970.  
  2971.      fprintf(spyfile, "%s\n", sz_buff);
  2972.  
  2973.      get_time();
  2974.  
  2975.      fprintf(spyfile, "%s\n", asctime(curtime));
  2976.      fprintf(spyfile, "\n");
  2977.  
  2978.   } /* end of write_db_stats() */
  2979.  
  2980. /*.............................................................
  2981. :                                                             :
  2982. :                                                             :
  2983. :   refresh_thread()                                          :
  2984. :                                                             :
  2985. :                                                             :
  2986. :............................................................*/
  2987.  
  2988.   void refresh_thread(void)
  2989.      {
  2990.      short i;
  2991.  
  2992.      while(!bit_flag.tend)
  2993.         {
  2994.         for(i=0;i<us_scan;i++)
  2995.            {
  2996.            DosSleep(SLEEP_TIME);
  2997.            }
  2998.  
  2999.         if (!bit_flag.draw)
  3000.            {
  3001.            WinPostMsg(hWndReFresh, WM_REDRAW, 0L, 0L);
  3002.            }
  3003.         }
  3004.  
  3005.      _endthread();
  3006.      } /* end of refresh_thread() */
  3007.  
  3008. /*.............................................................
  3009. :                                                             :
  3010. :                                                             :
  3011. :   wch_thread()                                              :
  3012. :                                                             :
  3013. :                                                             :
  3014. :............................................................*/
  3015.  
  3016.   void wch_thread(void)
  3017.      {
  3018.      static short i;
  3019.  
  3020.      for(i=0;i<(us_scan * 3);i++)
  3021.         {
  3022.         DosSleep(SLEEP_TIME);
  3023.         if (bit_flag.time)
  3024.            {
  3025.            _endthread();
  3026.            }
  3027.         }
  3028.  
  3029.      if (!bit_flag.time)
  3030.         {
  3031.         db_crash();
  3032.         }
  3033.  
  3034.      _endthread();
  3035.      } /* end of wch_thread() */
  3036.